litai-spex 1.0.0

package/README.md

@@ -0,0 +1,254 @@
+# LitAI-Spex
+
+A CLI tool for deploying files via SSH with configurable exclusions and post-deployment script execution.
+
+## Installation
+
+```bash
+# Clone or download the project
+cd litai-spex
+
+# Install dependencies
+npm install
+
+# Link globally for CLI access
+npm link
+```
+
+## Quick Start
+
+1. Initialize configuration in your project directory:
+   ```bash
+   litai-spex init
+   ```
+
+2. Edit `config.json` with your server details
+
+3. Deploy:
+   ```bash
+   litai-spex deploy
+   ```
+
+## Usage
+
+### Commands
+
+#### `litai-spex init`
+Creates a `config.json` file with default settings and a sample `deploy.sh` script.
+
+#### `litai-spex deploy [options]`
+Deploys files from the current directory to a remote server.
+
+**Options:**
+| Option | Description |
+|--------|-------------|
+| `-ip, --ip <host>` | Target server IP/hostname |
+| `-u, --user <username>` | SSH username |
+| `-p, --password <password>` | SSH password |
+| `-k, --key <path>` | Path to private key file |
+| `-dir, --directory <path>` | Target directory on remote server |
+| `-r, --run [script]` | Run script after deployment (default: deploy.sh) |
+| `-c, --config <path>` | Path to config file (default: config.json) |
+
+#### `litai-spex create-project [options]`
+Clones a git repository from URL specified in config or CLI.
+
+**Options:**
+| Option | Description |
+|--------|-------------|
+| `--repo <url>` | Git repository URL (overrides config) |
+| `--name <name>` | Directory name for the cloned project |
+| `-b, --branch <branch>` | Branch to clone |
+| `--depth <depth>` | Create a shallow clone with specified depth |
+| `-i, --install` | Auto-install npm dependencies after clone |
+| `-c, --config <path>` | Path to config file (default: config.json) |
+
+#### `litai-spex scan [options]`
+Scans local network for SSH hosts and optionally saves found hosts to config.
+
+**Options:**
+| Option | Description |
+|--------|-------------|
+| `-m, --mask <mask>` | IP mask to scan (e.g., 192.168.1). Auto-detected if not provided |
+| `-u, --user <username>` | SSH username to test (can also be set in config) |
+| `-p, --password <password>` | SSH password to test (can also be set in config) |
+| `-t, --timeout <ms>` | Connection timeout in milliseconds (default: 1000) |
+| `--threads <n>` | Number of parallel scans (default: 20) |
+| `-c, --config <path>` | Path to config file (default: config.json) |
+
+### Examples
+
+**Deploy using config file:**
+```bash
+litai-spex deploy
+```
+
+**Deploy with CLI options (override config):**
+```bash
+litai-spex deploy -ip 192.168.1.100 -u admin -p mypassword -dir /var/www/myapp
+```
+
+**Deploy using SSH key:**
+```bash
+litai-spex deploy -ip 192.168.1.100 -u admin -k ~/.ssh/id_rsa
+```
+
+**Deploy and run post-deployment script:**
+```bash
+litai-spex deploy -r              # Uses deploy.sh from config
+litai-spex deploy -r setup.sh     # Uses specific script
+```
+
+**Clone a project from config:**
+```bash
+litai-spex create-project
+```
+
+**Clone with CLI options:**
+```bash
+litai-spex create-project --repo https://github.com/user/repo.git
+litai-spex create-project --repo https://github.com/user/repo.git --name my-project
+litai-spex create-project --repo https://github.com/user/repo.git -b develop
+litai-spex create-project --repo https://github.com/user/repo.git -i  # Auto-install deps
+```
+
+**Scan local network for SSH hosts:**
+```bash
+litai-spex scan -u myuser                    # Auto-detect subnet, scan with username
+litai-spex scan -u myuser -p mypassword      # Scan with credentials
+litai-spex scan -m 192.168.1 -u admin        # Scan specific subnet
+litai-spex scan -u admin --threads 50        # Faster scan with more threads
+```
+
+## Configuration
+
+### config.json Structure
+
+```json
+{
+  "connection": {
+    "host": "192.168.1.100",
+    "username": "deploy",
+    "password": "your-password",
+    "privateKeyPath": "",
+    "targetDirectory": "/var/www/app"
+  },
+  "deploy": {
+    "excludeDirectories": [
+      "node_modules",
+      "logs",
+      ".git",
+      ".idea",
+      ".vscode"
+    ],
+    "excludeFiles": [
+      "package-lock.json",
+      ".env.local",
+      ".DS_Store",
+      "config.json"
+    ],
+    "excludePatterns": [
+      "*.log",
+      "*.tmp",
+      "*.bak"
+    ]
+  },
+  "scripts": {
+    "afterDeploy": "deploy.sh"
+  },
+  "project": {
+    "repositoryUrl": "https://github.com/username/repo.git"
+  }
+}
+```
+
+### Configuration Options
+
+#### Connection
+| Field | Description |
+|-------|-------------|
+| `host` | Server IP address or hostname |
+| `username` | SSH username |
+| `password` | SSH password (use this OR privateKeyPath) |
+| `privateKeyPath` | Path to SSH private key file |
+| `targetDirectory` | Remote directory to deploy to |
+
+#### Deploy Exclusions
+| Field | Description |
+|-------|-------------|
+| `excludeDirectories` | Array of directory names to skip |
+| `excludeFiles` | Array of file names to skip |
+| `excludePatterns` | Array of glob patterns to skip (e.g., `*.log`) |
+
+#### Project
+| Field | Description |
+|-------|-------------|
+| `repositoryUrl` | Default git repository URL for create-project command |
+
+### Default Exclusions
+
+**Directories:** `node_modules`, `logs`, `.git`, `.idea`, `.vscode`
+
+**Files:** `package-lock.json`, `.env.local`, `.DS_Store`
+
+**Patterns:** `*.log`, `*.tmp`
+
+## Post-Deployment Scripts
+
+Create a `deploy.sh` file in your project root:
+
+```bash
+#!/bin/bash
+# deploy.sh - runs on remote server after files are uploaded
+
+echo "Installing dependencies..."
+npm install --production
+
+echo "Building project..."
+npm run build
+
+echo "Restarting service..."
+sudo systemctl restart myapp
+
+echo "Deployment complete!"
+```
+
+Run it with:
+```bash
+litai-spex deploy -r
+```
+
+## Security Notes
+
+1. **Never commit `config.json`** - Add it to `.gitignore`
+2. **Use SSH keys** when possible instead of passwords
+3. **Secure your deploy.sh** - It runs with the connected user's permissions
+
+## CLI Priority
+
+Command-line options always override config file settings:
+
+```bash
+# Uses host from config, but overrides username
+litai-spex deploy -u differentuser
+```
+
+## Troubleshooting
+
+### Connection Refused
+- Check if SSH is running on the server
+- Verify the IP address and port
+- Check firewall settings
+
+### Authentication Failed
+- Verify username and password
+- Check SSH key permissions (`chmod 600 ~/.ssh/id_rsa`)
+- Ensure the key is added to `~/.ssh/authorized_keys` on the server
+
+### Permission Denied
+- Verify the user has write access to the target directory
+- Check directory permissions on the server
+
+## License
+
+MIT

package/package.json

@@ -0,0 +1,46 @@
+{
+  "name": "litai-spex",
+  "version": "1.0.0",
+  "description": "CLI tool for deploying files via SSH with configurable exclusions",
+  "main": "src/index.js",
+  "bin": {
+    "litai-spex": "./src/index.js"
+  },
+  "scripts": {
+    "start": "node src/index.js",
+    "test": "echo \"No tests yet\" && exit 0"
+  },
+  "keywords": [
+    "cli",
+    "ssh",
+    "deploy",
+    "sftp",
+    "upload",
+    "remote",
+    "deployment",
+    "devops"
+  ],
+  "author": "Litai Tech",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/litai-tech/litai.spex.cli.git"
+  },
+  "homepage": "https://github.com/litai-tech/litai.spex.cli#readme",
+  "bugs": {
+    "url": "https://github.com/litai-tech/litai.spex.cli/issues"
+  },
+  "engines": {
+    "node": ">=14.0.0"
+  },
+  "files": [
+    "src/**/*",
+    "README.md"
+  ],
+  "dependencies": {
+    "chalk": "^4.1.2",
+    "commander": "^11.1.0",
+    "node-ssh": "^13.2.0",
+    "ora": "^5.4.1"
+  }
+}

package/src/commands/create-project.js

@@ -0,0 +1,155 @@
+const chalk = require('chalk');
+const ora = require('ora');
+const { execSync } = require('child_process');
+const path = require('path');
+const fs = require('fs');
+const { loadConfig } = require('../utils/config');
+
+/**
+ * Create project command handler - clones a git repo from config
+ * @param {object} options - CLI options
+ */
+async function createProjectCommand(options) {
+  const spinner = ora();
+  
+  console.log(chalk.cyan('\n📦 LitAI-Spex Create Project\n'));
+  
+  try {
+    // Load configuration
+    spinner.start('Loading configuration...');
+    const configPath = options.config || 'config.json';
+    const config = loadConfig(configPath);
+    spinner.succeed('Configuration loaded');
+    
+    // Get repo URL from config or CLI
+    const repoUrl = options.repo || config.project?.repositoryUrl;
+    
+    if (!repoUrl) {
+      console.log(chalk.red('\n❌ No repository URL specified.'));
+      console.log(chalk.gray('\nProvide it via:'));
+      console.log(chalk.gray('   • CLI: litai-spex create-project --repo <url>'));
+      console.log(chalk.gray('   • Config: Add "project.repositoryUrl" to config.json\n'));
+      console.log(chalk.white('   Example config.json:'));
+      console.log(chalk.gray('   {'));
+      console.log(chalk.gray('     "project": {'));
+      console.log(chalk.cyan('       "repositoryUrl": "https://github.com/user/repo.git"'));
+      console.log(chalk.gray('     }'));
+      console.log(chalk.gray('   }\n'));
+      process.exit(1);
+    }
+    
+    // Determine target directory
+    const targetDir = options.dir || config.project?.targetDirectory || '.';
+    const fullTargetPath = path.resolve(process.cwd(), targetDir);
+    
+    // Extract repo name for folder name if cloning to current dir
+    let cloneDir = fullTargetPath;
+    if (targetDir === '.' && !options.name) {
+      // Will clone into repo name folder by default
+    } else if (options.name) {
+      cloneDir = path.resolve(process.cwd(), options.name);
+    }
+    
+    // Check if git is installed
+    try {
+      execSync('git --version', { stdio: 'pipe' });
+    } catch (e) {
+      console.log(chalk.red('\n❌ Git is not installed or not in PATH.'));
+      console.log(chalk.gray('   Please install Git: https://git-scm.com/downloads\n'));
+      process.exit(1);
+    }
+    
+    // Display clone info
+    console.log(chalk.gray('\n📋 Clone Details:'));
+    console.log(chalk.gray(`   Repository: ${repoUrl}`));
+    console.log(chalk.gray(`   Target: ${cloneDir === fullTargetPath ? 'Current directory' : cloneDir}`));
+    
+    if (options.branch) {
+      console.log(chalk.gray(`   Branch: ${options.branch}`));
+    }
+    console.log('');
+    
+    // Build git clone command
+    let gitCommand = 'git clone';
+    
+    if (options.branch) {
+      gitCommand += ` -b ${options.branch}`;
+    }
+    
+    if (options.depth) {
+      gitCommand += ` --depth ${options.depth}`;
+    }
+    
+    gitCommand += ` "${repoUrl}"`;
+    
+    if (options.name) {
+      gitCommand += ` "${options.name}"`;
+    }
+    
+    // Clone the repository
+    spinner.start('Cloning repository...');
+    
+    try {
+      execSync(gitCommand, { 
+        cwd: process.cwd(),
+        stdio: 'pipe'
+      });
+      spinner.succeed('Repository cloned successfully');
+    } catch (error) {
+      spinner.fail('Clone failed');
+      const errorMessage = error.stderr?.toString() || error.message;
+      console.log(chalk.red(`\n   ${errorMessage}`));
+      process.exit(1);
+    }
+    
+    // Determine the cloned directory name
+    let clonedDirName = options.name;
+    if (!clonedDirName) {
+      // Extract from URL
+      clonedDirName = repoUrl
+        .split('/')
+        .pop()
+        .replace(/\.git$/, '');
+    }
+    
+    const clonedPath = path.resolve(process.cwd(), clonedDirName);
+    
+    // Check if package.json exists and offer to install dependencies
+    const packageJsonPath = path.join(clonedPath, 'package.json');
+    if (fs.existsSync(packageJsonPath) && options.install !== false) {
+      if (options.install) {
+        spinner.start('Installing dependencies...');
+        try {
+          execSync('npm install', { 
+            cwd: clonedPath,
+            stdio: 'pipe'
+          });
+          spinner.succeed('Dependencies installed');
+        } catch (error) {
+          spinner.warn('Failed to install dependencies');
+          console.log(chalk.yellow(`   Run 'cd ${clonedDirName} && npm install' manually`));
+        }
+      } else {
+        console.log(chalk.gray(`\n💡 Tip: Run 'cd ${clonedDirName} && npm install' to install dependencies`));
+      }
+    }
+    
+    console.log(chalk.green(`\n✅ Project created successfully!`));
+    console.log(chalk.gray(`   Location: ${clonedPath}\n`));
+    
+    // Show next steps
+    console.log(chalk.cyan('📝 Next steps:'));
+    console.log(chalk.white(`   cd ${clonedDirName}`));
+    if (fs.existsSync(packageJsonPath) && !options.install) {
+      console.log(chalk.white('   npm install'));
+    }
+    console.log('');
+    
+  } catch (error) {
+    spinner.fail('Operation failed');
+    console.log(chalk.red(`\n❌ Error: ${error.message}\n`));
+    process.exit(1);
+  }
+}
+
+module.exports = { createProjectCommand };

package/src/commands/deploy.js

@@ -0,0 +1,155 @@
+const chalk = require('chalk');
+const ora = require('ora');
+const path = require('path');
+const { loadConfig, mergeWithCliOptions, validateConfig } = require('../utils/config');
+const { scanDirectory, getRemoteDirectories } = require('../utils/fileScanner');
+const { SSHDeployer } = require('../utils/sshDeployer');
+
+/**
+ * Deploy command handler
+ * @param {object} options - CLI options
+ */
+async function deployCommand(options) {
+  const spinner = ora();
+  const deployer = new SSHDeployer();
+  
+  console.log(chalk.cyan('\n🚀 LitAI-Spex Deploy\n'));
+  
+  try {
+    // Load and merge configuration
+    spinner.start('Loading configuration...');
+    const configPath = options.config || 'config.json';
+    let config = loadConfig(configPath);
+    config = mergeWithCliOptions(config, options);
+    spinner.succeed('Configuration loaded');
+    
+    // Validate configuration
+    const validation = validateConfig(config);
+    if (!validation.isValid) {
+      console.log(chalk.red('\n❌ Missing required configuration:'));
+      validation.missing.forEach(field => {
+        console.log(chalk.yellow(`   • ${field}`));
+      });
+      console.log(chalk.gray('\nRun `litai-spex init` to create a config file or provide options via CLI.\n'));
+      process.exit(1);
+    }
+    
+    // Display connection info
+    console.log(chalk.gray('\n📡 Connection Details:'));
+    console.log(chalk.gray(`   Host: ${config.connection.host}`));
+    console.log(chalk.gray(`   User: ${config.connection.username}`));
+    console.log(chalk.gray(`   Target: ${config.connection.targetDirectory}`));
+    console.log(chalk.gray(`   Auth: ${config.connection.privateKeyPath ? 'Private Key' : 'Password'}\n`));
+    
+    // Scan local files
+    spinner.start('Scanning local files...');
+    const sourceDir = process.cwd();
+    const files = scanDirectory(sourceDir, config.deploy);
+    const directories = getRemoteDirectories(files);
+    spinner.succeed(`Found ${chalk.green(files.length)} files to deploy`);
+    
+    if (files.length === 0) {
+      console.log(chalk.yellow('\n⚠️  No files to deploy. Check your exclude settings.\n'));
+      process.exit(0);
+    }
+    
+    // Display exclusions
+    console.log(chalk.gray('\n📋 Exclusions:'));
+    console.log(chalk.gray(`   Directories: ${config.deploy.excludeDirectories.join(', ')}`));
+    console.log(chalk.gray(`   Files: ${config.deploy.excludeFiles.join(', ')}`));
+    console.log(chalk.gray(`   Patterns: ${config.deploy.excludePatterns.join(', ')}\n`));
+    
+    // Connect to server
+    spinner.start(`Connecting to ${config.connection.host}...`);
+    await deployer.connect(config.connection);
+    spinner.succeed('Connected to server');
+    
+    // Get server info
+    try {
+      const serverInfo = await deployer.getServerInfo();
+      console.log(chalk.gray(`   Server: ${serverInfo.hostname} (${serverInfo.os})`));
+      console.log(chalk.gray(`   Uptime: ${serverInfo.uptime}\n`));
+    } catch (e) {
+      // Server info is optional, don't fail if it doesn't work
+    }
+    
+    // Create directories
+    if (directories.length > 0) {
+      spinner.start(`Creating ${directories.length} directories...`);
+      await deployer.createDirectories(config.connection.targetDirectory, directories);
+      spinner.succeed(`Created ${directories.length} directories`);
+    }
+    
+    // Upload files
+    console.log(chalk.cyan('\n📤 Uploading files...\n'));
+    
+    let lastPercent = -1;
+    await deployer.uploadFiles(
+      config.connection.targetDirectory,
+      files,
+      (current, total, filename) => {
+        const percent = Math.round((current / total) * 100);
+        if (percent !== lastPercent) {
+          lastPercent = percent;
+          process.stdout.clearLine(0);
+          process.stdout.cursorTo(0);
+          const bar = '█'.repeat(Math.floor(percent / 2)) + '░'.repeat(50 - Math.floor(percent / 2));
+          process.stdout.write(chalk.cyan(`   [${bar}] ${percent}% - ${filename}`));
+        }
+      }
+    );
+    
+    console.log('\n');
+    console.log(chalk.green(`✅ Successfully uploaded ${files.length} files\n`));
+    
+    // Execute script if requested
+    if (options.run !== undefined) {
+      const scriptName = typeof options.run === 'string' ? options.run : config.scripts.afterDeploy;
+      
+      console.log(chalk.cyan(`\n🔧 Executing script: ${scriptName}\n`));
+      spinner.start('Running script...');
+      
+      try {
+        const result = await deployer.executeScript(config.connection.targetDirectory, scriptName);
+        spinner.succeed('Script executed');
+        
+        if (result.stdout) {
+          console.log(chalk.gray('\n📋 Script output:'));
+          console.log(chalk.white(result.stdout));
+        }
+        
+        if (result.stderr) {
+          console.log(chalk.yellow('\n⚠️  Script stderr:'));
+          console.log(chalk.yellow(result.stderr));
+        }
+        
+        if (result.code !== 0) {
+          console.log(chalk.yellow(`\n⚠️  Script exited with code: ${result.code}`));
+        }
+      } catch (scriptError) {
+        spinner.fail('Script execution failed');
+        console.log(chalk.red(`   ${scriptError.message}`));
+      }
+    }
+    
+    // Disconnect
+    deployer.disconnect();
+    
+    console.log(chalk.green('\n🎉 Deployment completed successfully!\n'));
+    
+  } catch (error) {
+    spinner.fail('Deployment failed');
+    console.log(chalk.red(`\n❌ Error: ${error.message}\n`));
+    
+    if (error.message.includes('ECONNREFUSED')) {
+      console.log(chalk.yellow('   Hint: Check if the server is running and accessible.'));
+    } else if (error.message.includes('Authentication')) {
+      console.log(chalk.yellow('   Hint: Check your username and password/key.'));
+    }
+    
+    deployer.disconnect();
+    process.exit(1);
+  }
+}
+
+module.exports = { deployCommand };