litai-spex 1.0.0

package/src/commands/init.js

@@ -0,0 +1,114 @@
+const chalk = require('chalk');
+const fs = require('fs');
+const path = require('path');
+const { DEFAULT_CONFIG } = require('../utils/config');
+
+/**
+ * Init command handler - creates a default config.json file
+ */
+async function initCommand() {
+  const configPath = path.resolve(process.cwd(), 'config.json');
+  
+  console.log(chalk.cyan('\n🔧 LitAI-Spex Initialize\n'));
+  
+  // Check if config already exists
+  if (fs.existsSync(configPath)) {
+    console.log(chalk.yellow('⚠️  config.json already exists in this directory.'));
+    console.log(chalk.gray('   Delete it first if you want to create a new one.\n'));
+    process.exit(1);
+  }
+  
+  // Create config file
+  const configContent = {
+    connection: {
+      host: '192.168.1.100',
+      username: 'deploy',
+      password: '',
+      privateKeyPath: '',
+      targetDirectory: '/home/rock/ui'
+    },
+    deploy: {
+      excludeDirectories: [
+        'node_modules',
+        'logs',
+        '.git',
+        '.idea',
+        '.vscode',
+        'coverage',
+        'dist',
+        '.cache'
+      ],
+      excludeFiles: [
+        'package-lock.json',
+        '.env.local',
+        '.env.development',
+        '.DS_Store',
+        'config.json',
+        'Thumbs.db'
+      ],
+      excludePatterns: [
+        '*.log',
+        '*.tmp',
+        '*.bak',
+        '*.swp',
+        '*~'
+      ]
+    },
+    scripts: {
+      afterDeploy: 'deploy.sh'
+    },
+    project: {
+      repositoryUrl: 'https://github.com/username/repo.git'
+    }
+  };
+  
+  fs.writeFileSync(configPath, JSON.stringify(configContent, null, 2));
+  
+  console.log(chalk.green('✅ Created config.json\n'));
+  console.log(chalk.gray('📝 Configuration file created with default settings.'));
+  console.log(chalk.gray('   Edit config.json to set your connection details:\n'));
+  console.log(chalk.white('   {'));
+  console.log(chalk.white('     "connection": {'));
+  console.log(chalk.cyan('       "host": "your-server-ip",'));
+  console.log(chalk.cyan('       "username": "your-username",'));
+  console.log(chalk.cyan('       "password": "your-password",'));
+  console.log(chalk.gray('       // OR use private key:'));
+  console.log(chalk.cyan('       "privateKeyPath": "~/.ssh/id_rsa",'));
+  console.log(chalk.cyan('       "targetDirectory": "/var/www/app"'));
+  console.log(chalk.white('     }'));
+  console.log(chalk.white('   }\n'));
+  
+  console.log(chalk.gray('🔒 Security tip: Add config.json to .gitignore!\n'));
+  
+  // Create sample deploy.sh if it doesn't exist
+  const deployShPath = path.resolve(process.cwd(), 'deploy.sh');
+  if (!fs.existsSync(deployShPath)) {
+    const deployShContent = `#!/bin/bash
+# Deploy script - runs after files are uploaded
+# This script runs on the remote server
+
+echo "🚀 Running post-deployment tasks..."
+
+# Example: Install dependencies
+npm install
+
+# Example: Build the project
+# npm run build
+
+# Example: Restart service
+# sudo systemctl restart myapp
+
+# Example: Clear cache
+# rm -rf /tmp/app-cache/*
+
+echo "✅ Post-deployment tasks completed!"
+`;
+    
+    fs.writeFileSync(deployShPath, deployShContent);
+    console.log(chalk.green('✅ Created sample deploy.sh\n'));
+    console.log(chalk.gray('   Edit deploy.sh to add your post-deployment commands.'));
+    console.log(chalk.gray('   Run with: litai-spex deploy -r\n'));
+  }
+}
+
+module.exports = { initCommand };

package/src/commands/ping.js

@@ -0,0 +1,165 @@
+const chalk = require('chalk');
+const ora = require('ora');
+const { NodeSSH } = require('node-ssh');
+const { loadConfig } = require('../utils/config');
+
+/**
+ * Quick TCP port check for SSH (port 22)
+ * @param {string} ip - IP address
+ * @param {number} timeout - Timeout in ms
+ * @returns {Promise<object>} { success: boolean, duration: number }
+ */
+function checkSSHPort(ip, timeout = 5000) {
+  return new Promise((resolve) => {
+    const net = require('net');
+    const socket = new net.Socket();
+    const startTime = Date.now();
+
+    socket.setTimeout(timeout);
+
+    socket.on('connect', () => {
+      const duration = Date.now() - startTime;
+      socket.destroy();
+      resolve({ success: true, duration });
+    });
+
+    socket.on('timeout', () => {
+      const duration = Date.now() - startTime;
+      socket.destroy();
+      resolve({ success: false, duration });
+    });
+
+    socket.on('error', (err) => {
+      const duration = Date.now() - startTime;
+      socket.destroy();
+      resolve({ success: false, duration });
+    });
+
+    socket.connect(22, ip);
+  });
+}
+
+/**
+ * Try to connect to SSH on given IP
+ * @param {string} ip - IP address
+ * @param {string} username - SSH username
+ * @param {string} password - SSH password (optional)
+ * @param {number} timeout - Connection timeout in ms
+ * @returns {Promise<object>} Connection result
+ */
+async function trySSHConnection(ip, username, password, timeout = 10000) {
+  const ssh = new NodeSSH();
+
+  try {
+    const config = {
+      host: ip,
+      username: username,
+      readyTimeout: timeout,
+      tryKeyboard: false
+    };
+
+    if (password) {
+      config.password = password;
+    } else {
+      // Try with agent or default keys
+      config.agent = process.env.SSH_AUTH_SOCK;
+    }
+    console.log(config)
+    await ssh.connect(config);
+    ssh.dispose();
+    return { success: true, authenticated: true, error: null };
+  } catch (error) {
+    ssh.dispose();
+
+    // Check if it's an auth error (means SSH is running but wrong credentials)
+    if (error.message.includes('Authentication') ||
+        error.message.includes('authentication') ||
+        error.message.includes('All configured authentication methods failed')) {
+      return { success: true, authenticated: false, error: 'Authentication failed' };
+    }
+
+    return { success: false, authenticated: false, error: error.message };
+  }
+}
+
+/**
+ * Ping command handler
+ * @param {string} host - Host IP or hostname
+ * @param {object} options - CLI options
+ */
+async function pingCommand(host, options) {
+  const spinner = ora();
+
+  console.log(chalk.cyan('\n🔍 LitAI-Spex Connection Tester\n'));
+
+  if (!host) {
+    console.log(chalk.red('❌ No host specified.'));
+    console.log(chalk.gray('\nUsage:'));
+    console.log(chalk.gray('   litai-spex ping <host>'));
+    console.log(chalk.gray('   litai-spex ping <host> -u <username>'));
+    console.log(chalk.gray('   litai-spex ping <host> -u <username> -p <password>\n'));
+    process.exit(1);
+  }
+
+  try {
+    const timeout = options.timeout || 5000;
+
+    console.log(chalk.gray(`Target: ${host}`));
+    console.log(chalk.gray(`Timeout: ${timeout}ms\n`));
+
+    // Step 1: Check SSH port
+    spinner.start(`Checking SSH port (22) on ${host}...`);
+    const portCheck = await checkSSHPort(host, timeout);
+
+    if (!portCheck.success) {
+      spinner.fail(`SSH port is not accessible on ${host} (took ${portCheck.duration}ms)`);
+      console.log(chalk.yellow('\n💡 Possible reasons:'));
+      console.log(chalk.gray('   • Host is down or unreachable'));
+      console.log(chalk.gray('   • Firewall blocking port 22'));
+      console.log(chalk.gray('   • SSH service not running'));
+      console.log(chalk.gray('   • Network timeout (try increasing with --timeout)\n'));
+      process.exit(1);
+    }
+
+    spinner.succeed(`SSH port is ${chalk.green('OPEN')} on ${host} ${chalk.gray(`(${portCheck.duration}ms)`)}`);
+    console.log(chalk.cyan(`\n⏱️  Connection time: ${portCheck.duration}ms`));
+    console.log(chalk.gray(`   Recommended timeout for scan: ${Math.ceil(portCheck.duration * 1.5)}ms or higher\n`));
+
+    // Step 2: Try SSH connection if username provided
+    if (options.user) {
+      const username = options.user;
+      const password = options.password;
+
+      console.log(chalk.gray(`Attempting SSH authentication as ${username}...\n`));
+
+      spinner.start(`Connecting to ${username}@${host}...`);
+      const sshStartTime = Date.now();
+      const result = await trySSHConnection(host, username, password, timeout);
+      const sshDuration = Date.now() - sshStartTime;
+
+      if (result.authenticated) {
+        spinner.succeed(`SSH connection ${chalk.green('SUCCESSFUL')} - authenticated as ${username} ${chalk.gray(`(${sshDuration}ms)`)}`);
+        console.log(chalk.green('\n✅ You can connect to this host!\n'));
+      } else if (result.success) {
+        spinner.warn(`SSH is running but ${chalk.yellow('authentication failed')} ${chalk.gray(`(${sshDuration}ms)`)}`);
+        console.log(chalk.yellow('\n⚠️  The host is accessible but credentials are incorrect.'));
+        console.log(chalk.gray('\nTry:'));
+        console.log(chalk.gray(`   ssh ${username}@${host}`));
+        console.log(chalk.gray('   to test manually\n'));
+      } else {
+        spinner.fail(`SSH connection failed ${chalk.gray(`(${sshDuration}ms)`)}`);
+        console.log(chalk.red(`\n❌ Error: ${result.error}\n`));
+      }
+    } else {
+      console.log(chalk.green('\n✅ SSH port is accessible!'));
+      console.log(chalk.gray('\n💡 To test SSH authentication, add: -u <username>\n'));
+    }
+
+  } catch (error) {
+    spinner.fail('Ping failed');
+    console.log(chalk.red(`\n❌ Error: ${error.message}\n`));
+    process.exit(1);
+  }
+}
+
+module.exports = { pingCommand };

package/src/commands/scan.js

@@ -0,0 +1,313 @@
+const chalk = require('chalk');
+const ora = require('ora');
+const { NodeSSH } = require('node-ssh');
+const os = require('os');
+const fs = require('fs');
+const path = require('path');
+const readline = require('readline');
+const { loadConfig } = require('../utils/config');
+
+/**
+ * Get local IP address
+ * @returns {string|null} Local IP address
+ */
+function getLocalIP() {
+  const interfaces = os.networkInterfaces();
+  
+  for (const name of Object.keys(interfaces)) {
+    for (const iface of interfaces[name]) {
+      // Skip internal and non-IPv4 addresses
+      if (iface.family === 'IPv4' && !iface.internal) {
+        return iface.address;
+      }
+    }
+  }
+  
+  return null;
+}
+
+/**
+ * Generate IP mask from local IP
+ * @param {string} ip - Local IP address
+ * @returns {string} IP mask (e.g., "192.168.0")
+ */
+function generateMask(ip) {
+  const parts = ip.split('.');
+  return `${parts[0]}.${parts[1]}.${parts[2]}`;
+}
+
+/**
+ * Generate all IPs in a subnet
+ * @param {string} mask - IP mask (e.g., "192.168.0")
+ * @param {string} localIP - Local IP to exclude
+ * @returns {string[]} Array of IP addresses
+ */
+function generateIPRange(mask, localIP) {
+  const ips = [];
+  for (let i = 1; i < 255; i++) {
+    const ip = `${mask}.${i}`;
+    if (ip !== localIP) {
+      ips.push(ip);
+    }
+  }
+  return ips;
+}
+
+/**
+ * Try to connect to SSH on given IP
+ * @param {string} ip - IP address
+ * @param {string} username - SSH username
+ * @param {string} password - SSH password (optional)
+ * @param {number} timeout - Connection timeout in ms
+ * @returns {Promise<boolean>} True if SSH port is accessible
+ */
+async function trySSHConnection(ip, username, password, timeout = 3000) {
+  const ssh = new NodeSSH();
+  
+  try {
+    const config = {
+      host: ip,
+      username: username,
+      readyTimeout: timeout,
+      tryKeyboard: false
+    };
+    
+    if (password) {
+      config.password = password;
+    } else {
+      // Try with agent or default keys
+      config.agent = process.env.SSH_AUTH_SOCK;
+    }
+    
+    await ssh.connect(config);
+    ssh.dispose();
+    return { success: true, authenticated: true };
+  } catch (error) {
+    ssh.dispose();
+    
+    // Check if it's an auth error (means SSH is running but wrong credentials)
+    if (error.message.includes('Authentication') || 
+        error.message.includes('authentication') ||
+        error.message.includes('All configured authentication methods failed')) {
+      return { success: true, authenticated: false };
+    }
+    
+    return { success: false, authenticated: false };
+  }
+}
+
+/**
+ * Quick TCP port check for SSH (port 22)
+ * @param {string} ip - IP address
+ * @param {number} timeout - Timeout in ms
+ * @returns {Promise<boolean>}
+ */
+function checkSSHPort(ip, timeout = 1000) {
+  return new Promise((resolve) => {
+    const net = require('net');
+    const socket = new net.Socket();
+    
+    socket.setTimeout(timeout);
+    
+    socket.on('connect', () => {
+      socket.destroy();
+      resolve(true);
+    });
+    
+    socket.on('timeout', () => {
+      socket.destroy();
+      resolve(false);
+    });
+    
+    socket.on('error', () => {
+      socket.destroy();
+      resolve(false);
+    });
+    
+    socket.connect(22, ip);
+  });
+}
+
+/**
+ * Prompt user for input
+ * @param {string} question - Question to ask
+ * @returns {Promise<string>} User input
+ */
+function prompt(question) {
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+  
+  return new Promise((resolve) => {
+    rl.question(question, (answer) => {
+      rl.close();
+      resolve(answer.trim().toLowerCase());
+    });
+  });
+}
+
+/**
+ * Save IP to config file
+ * @param {string} configPath - Path to config file
+ * @param {string} ip - IP to save
+ */
+function saveToConfig(configPath, ip) {
+  const fullPath = path.resolve(process.cwd(), configPath);
+  
+  let config = {};
+  if (fs.existsSync(fullPath)) {
+    const content = fs.readFileSync(fullPath, 'utf8');
+    config = JSON.parse(content);
+  }
+  
+  if (!config.connection) {
+    config.connection = {};
+  }
+  
+  config.connection.host = ip;
+  
+  fs.writeFileSync(fullPath, JSON.stringify(config, null, 2));
+}
+
+/**
+ * Scan command handler
+ * @param {object} options - CLI options
+ */
+async function scanCommand(options) {
+  const spinner = ora();
+  
+  console.log(chalk.cyan('\n🔍 LitAI-Spex Network Scanner\n'));
+  
+  try {
+    // Load config for username/password
+    const configPath = options.config || 'config.json';
+    let config = {};
+    
+    try {
+      config = loadConfig(configPath);
+    } catch (e) {
+      // Config might not exist, that's OK
+    }
+    
+    // Get username from options or config
+    const username = options.user || config.connection?.username;
+    const password = options.password || config.connection?.password;
+    
+    if (!username) {
+      console.log(chalk.red('❌ No username specified.'));
+      console.log(chalk.gray('\nProvide it via:'));
+      console.log(chalk.gray('   • CLI: litai-spex scan -u <username>'));
+      console.log(chalk.gray('   • Config: Set "connection.username" in config.json\n'));
+      process.exit(1);
+    }
+    
+    // Get local IP
+    spinner.start('Detecting local IP address...');
+    const localIP = getLocalIP();
+    
+    if (!localIP) {
+      spinner.fail('Could not detect local IP address');
+      process.exit(1);
+    }
+    spinner.succeed(`Local IP: ${chalk.green(localIP)}`);
+    
+    // Generate or use provided mask
+    const mask = options.mask || generateMask(localIP);
+    console.log(chalk.gray(`   Scanning subnet: ${mask}.*\n`));
+    
+    // Generate IP range
+    const ips = generateIPRange(mask, localIP);
+    const foundHosts = [];
+    
+    console.log(chalk.cyan('📡 Scanning for SSH hosts...\n'));
+    
+    // Batch size for parallel scanning
+    const batchSize = options.threads || 1;
+    const timeout = options.timeout || 200;
+    
+    // Progress tracking
+    let scanned = 0;
+    const total = ips.length;
+    
+    // Scan in batches
+    for (let i = 0; i < ips.length; i += batchSize) {
+      const batch = ips.slice(i, i + batchSize);
+      
+      const results = await Promise.all(
+        batch.map(async (ip) => {
+          // First do a quick port check
+          const portOpen = await checkSSHPort(ip, timeout);
+          scanned++;
+          
+          // Update progress
+          const percent = Math.round((scanned / total) * 100);
+          const bar = '█'.repeat(Math.floor(percent / 2)) + '░'.repeat(50 - Math.floor(percent / 2));
+          process.stdout.clearLine(0);
+          process.stdout.cursorTo(0);
+          process.stdout.write(chalk.gray(`   [${bar}] ${percent}% (${scanned}/${total})`));
+          
+          if (portOpen) {
+            return { ip, portOpen: true };
+          }
+          return { ip, portOpen: false };
+        })
+      );
+      
+      // Collect hosts with open SSH port
+      for (const result of results) {
+        if (result.portOpen) {
+          foundHosts.push(result.ip);
+        }
+      }
+    }
+    
+    console.log('\n\n');
+    
+    if (foundHosts.length === 0) {
+      console.log(chalk.yellow('⚠️  No SSH hosts found in the subnet.\n'));
+      process.exit(0);
+    }
+    
+    console.log(chalk.green(`✅ Found ${foundHosts.length} host(s) with SSH port open:\n`));
+    
+    // Now try to authenticate to found hosts
+    for (const ip of foundHosts) {
+      spinner.start(`Testing SSH connection to ${ip}...`);
+      
+      const result = await trySSHConnection(ip, username, password, 5000);
+      
+      if (result.authenticated) {
+        spinner.succeed(`${chalk.green(ip)} - SSH accessible ${chalk.green('(authenticated)')}`);
+      } else if (result.success) {
+        spinner.succeed(`${chalk.green(ip)} - SSH accessible ${chalk.yellow('(auth required)')}`);
+      } else {
+        spinner.info(`${chalk.gray(ip)} - SSH port open but connection failed`);
+        continue;
+      }
+      
+      // Ask user if they want to save this IP
+      const answer = await prompt(chalk.cyan(`   Save ${ip} to config.json? (y/n): `));
+      
+      if (answer === 'y' || answer === 'yes') {
+        try {
+          saveToConfig(configPath, ip);
+          console.log(chalk.green(`   ✅ Saved ${ip} to ${configPath}\n`));
+        } catch (error) {
+          console.log(chalk.red(`   ❌ Failed to save: ${error.message}\n`));
+        }
+      } else {
+        console.log(chalk.gray('   Skipped.\n'));
+      }
+    }
+    
+    console.log(chalk.green('\n🎉 Scan completed!\n'));
+    
+  } catch (error) {
+    spinner.fail('Scan failed');
+    console.log(chalk.red(`\n❌ Error: ${error.message}\n`));
+    process.exit(1);
+  }
+}
+
+module.exports = { scanCommand };

package/src/index.js

@@ -0,0 +1,69 @@
+#!/usr/bin/env node
+
+const { program } = require('commander');
+const path = require('path');
+const { deployCommand } = require('./commands/deploy');
+const { initCommand } = require('./commands/init');
+const { createProjectCommand } = require('./commands/create-project');
+const { scanCommand } = require('./commands/scan');
+const { pingCommand } = require('./commands/ping');
+const pkg = require('../package.json');
+
+program
+  .name('litai-spex')
+  .description('CLI tool for deploying files via SSH')
+  .version(pkg.version);
+
+program
+  .command('deploy')
+  .description('Deploy files from current directory to remote server via SSH')
+  .option('-ip, --ip <host>', 'Target server IP/hostname')
+  .option('-u, --user <username>', 'SSH username')
+  .option('-p, --password <password>', 'SSH password')
+  .option('-dir, --directory <path>', 'Target directory on remote server')
+  .option('-k, --key <path>', 'Path to private key file (alternative to password)')
+  .option('-r, --run [script]', 'Run script after deployment (default: deploy.sh)')
+  .option('-c, --config <path>', 'Path to config file (default: config.json)')
+  .action(deployCommand);
+
+program
+  .command('init')
+  .description('Initialize a config.json file with default settings')
+  .action(initCommand);
+
+program
+  .command('create-project')
+  .description('Clone a git repository from URL specified in config or CLI')
+  .option('--repo <url>', 'Git repository URL (overrides config)')
+  .option('--name <n>', 'Directory name for the cloned project')
+  .option('-b, --branch <branch>', 'Branch to clone')
+  .option('--depth <depth>', 'Create a shallow clone with specified depth')
+  .option('-i, --install', 'Auto-install npm dependencies after clone')
+  .option('-c, --config <path>', 'Path to config file (default: config.json)')
+  .action(createProjectCommand);
+
+program
+  .command('scan')
+  .description('Scan local network for SSH hosts')
+  .option('-m, --mask <mask>', 'IP mask to scan (e.g., 192.168.1)')
+  .option('-u, --user <username>', 'SSH username to test')
+  .option('-p, --password <password>', 'SSH password to test')
+  .option('-t, --timeout <ms>', 'Connection timeout in milliseconds (default: 1000)', parseInt)
+  .option('--threads <n>', 'Number of parallel scans (default: 20)', parseInt)
+  .option('-c, --config <path>', 'Path to config file (default: config.json)')
+  .action(scanCommand);
+
+program
+  .command('ping <host>')
+  .description('Test SSH connectivity to a specific host')
+  .option('-u, --user <username>', 'SSH username to test authentication')
+  .option('-p, --password <password>', 'SSH password to test authentication')
+  .option('-t, --timeout <ms>', 'Connection timeout in milliseconds (default: 5000)', parseInt)
+  .action(pingCommand);
+
+program.parse(process.argv);
+
+// Show help if no command provided
+if (!process.argv.slice(2).length) {
+  program.outputHelp();
+}