litai-spex 1.0.0

package/src/utils/config.js

@@ -0,0 +1,115 @@
+const fs = require('fs');
+const path = require('path');
+
+const DEFAULT_CONFIG = {
+  connection: {
+    host: '',
+    username: '',
+    password: '',
+    privateKeyPath: '',
+    targetDirectory: '/var/www/app'
+  },
+  deploy: {
+    excludeDirectories: ['node_modules', 'logs', '.git', '.idea', '.vscode'],
+    excludeFiles: ['package-lock.json', '.env.local', '.DS_Store'],
+    excludePatterns: ['*.log', '*.tmp']
+  },
+  scripts: {
+    afterDeploy: 'deploy.sh'
+  },
+  project: {
+    repositoryUrl: '',
+    targetDirectory: '.'
+  }
+};
+
+/**
+ * Load configuration from file
+ * @param {string} configPath - Path to config file
+ * @returns {object} Configuration object
+ */
+function loadConfig(configPath) {
+  const fullPath = path.resolve(process.cwd(), configPath);
+  
+  if (!fs.existsSync(fullPath)) {
+    return { ...DEFAULT_CONFIG };
+  }
+  
+  try {
+    const configContent = fs.readFileSync(fullPath, 'utf8');
+    const userConfig = JSON.parse(configContent);
+    
+    // Deep merge with defaults
+    return {
+      connection: { ...DEFAULT_CONFIG.connection, ...userConfig.connection },
+      deploy: {
+        excludeDirectories: userConfig.deploy?.excludeDirectories || DEFAULT_CONFIG.deploy.excludeDirectories,
+        excludeFiles: userConfig.deploy?.excludeFiles || DEFAULT_CONFIG.deploy.excludeFiles,
+        excludePatterns: userConfig.deploy?.excludePatterns || DEFAULT_CONFIG.deploy.excludePatterns
+      },
+      scripts: { ...DEFAULT_CONFIG.scripts, ...userConfig.scripts },
+      project: { ...DEFAULT_CONFIG.project, ...userConfig.project }
+    };
+  } catch (error) {
+    throw new Error(`Failed to parse config file: ${error.message}`);
+  }
+}
+
+/**
+ * Merge CLI options with config file settings (CLI takes precedence)
+ * @param {object} config - Config from file
+ * @param {object} options - CLI options
+ * @returns {object} Merged configuration
+ */
+function mergeWithCliOptions(config, options) {
+  return {
+    ...config,
+    connection: {
+      ...config.connection,
+      host: options.ip || config.connection.host,
+      username: options.user || config.connection.username,
+      password: options.password || config.connection.password,
+      privateKeyPath: options.key || config.connection.privateKeyPath,
+      targetDirectory: options.directory || config.connection.targetDirectory
+    }
+  };
+}
+
+/**
+ * Validate that required connection settings are present
+ * @param {object} config - Configuration object
+ * @returns {object} Object with isValid boolean and missing fields array
+ */
+function validateConfig(config) {
+  const missing = [];
+  
+  if (!config.connection.host) missing.push('host (use -ip or set in config.json)');
+  if (!config.connection.username) missing.push('username (use -u or set in config.json)');
+  if (!config.connection.password && !config.connection.privateKeyPath) {
+    missing.push('password or privateKeyPath (use -p/-k or set in config.json)');
+  }
+  if (!config.connection.targetDirectory) missing.push('targetDirectory (use -dir or set in config.json)');
+  
+  return {
+    isValid: missing.length === 0,
+    missing
+  };
+}
+
+/**
+ * Create default config file
+ * @param {string} configPath - Path to create config file
+ */
+function createDefaultConfig(configPath) {
+  const fullPath = path.resolve(process.cwd(), configPath);
+  fs.writeFileSync(fullPath, JSON.stringify(DEFAULT_CONFIG, null, 2));
+  return fullPath;
+}
+
+module.exports = {
+  DEFAULT_CONFIG,
+  loadConfig,
+  mergeWithCliOptions,
+  validateConfig,
+  createDefaultConfig
+};

package/src/utils/fileScanner.js

@@ -0,0 +1,101 @@
+const fs = require('fs');
+const path = require('path');
+
+/**
+ * Check if a filename matches any pattern (supports * wildcard)
+ * @param {string} filename - File name to check
+ * @param {string[]} patterns - Array of patterns
+ * @returns {boolean}
+ */
+function matchesPattern(filename, patterns) {
+  return patterns.some(pattern => {
+    if (pattern.includes('*')) {
+      const regex = new RegExp('^' + pattern.replace(/\*/g, '.*') + '$');
+      return regex.test(filename);
+    }
+    return filename === pattern;
+  });
+}
+
+/**
+ * Recursively scan directory and collect files to deploy
+ * @param {string} dir - Directory to scan
+ * @param {object} excludeConfig - Exclusion configuration
+ * @param {string} baseDir - Base directory for relative paths
+ * @returns {Array<{local: string, remote: string}>} Array of file mappings
+ */
+function scanDirectory(dir, excludeConfig, baseDir = dir) {
+  const { excludeDirectories, excludeFiles, excludePatterns } = excludeConfig;
+  const files = [];
+  
+  const items = fs.readdirSync(dir);
+  
+  for (const item of items) {
+    const fullPath = path.join(dir, item);
+    const relativePath = path.relative(baseDir, fullPath);
+    const stat = fs.statSync(fullPath);
+    
+    if (stat.isDirectory()) {
+      // Check if directory should be excluded
+      if (excludeDirectories.includes(item)) {
+        continue;
+      }
+      
+      // Recursively scan subdirectory
+      const subFiles = scanDirectory(fullPath, excludeConfig, baseDir);
+      files.push(...subFiles);
+    } else {
+      // Check if file should be excluded
+      if (excludeFiles.includes(item)) {
+        continue;
+      }
+      
+      // Check if file matches any exclude pattern
+      if (matchesPattern(item, excludePatterns)) {
+        continue;
+      }
+      
+      files.push({
+        local: fullPath,
+        remote: relativePath.replace(/\\/g, '/') // Normalize to forward slashes for remote
+      });
+    }
+  }
+  
+  return files;
+}
+
+/**
+ * Get all directories that need to be created on remote
+ * @param {Array<{local: string, remote: string}>} files - File mappings
+ * @returns {string[]} Array of directory paths
+ */
+function getRemoteDirectories(files) {
+  const dirs = new Set();
+  
+  for (const file of files) {
+    const dir = path.dirname(file.remote);
+    if (dir && dir !== '.') {
+      // Add all parent directories as well
+      const parts = dir.split('/');
+      let current = '';
+      for (const part of parts) {
+        current = current ? `${current}/${part}` : part;
+        dirs.add(current);
+      }
+    }
+  }
+  
+  // Sort by depth (shorter paths first) to ensure parent dirs are created first
+  return Array.from(dirs).sort((a, b) => {
+    const depthA = a.split('/').length;
+    const depthB = b.split('/').length;
+    return depthA - depthB;
+  });
+}
+
+module.exports = {
+  scanDirectory,
+  getRemoteDirectories,
+  matchesPattern
+};

package/src/utils/sshDeployer.js

@@ -0,0 +1,138 @@
+const { NodeSSH } = require('node-ssh');
+const fs = require('fs');
+const path = require('path');
+
+class SSHDeployer {
+  constructor() {
+    this.ssh = new NodeSSH();
+    this.connected = false;
+  }
+  
+  /**
+   * Connect to remote server
+   * @param {object} connectionConfig - Connection configuration
+   */
+  async connect(connectionConfig) {
+    const config = {
+      host: connectionConfig.host,
+      username: connectionConfig.username
+    };
+    
+    if (connectionConfig.privateKeyPath) {
+      const keyPath = path.resolve(process.cwd(), connectionConfig.privateKeyPath);
+      if (!fs.existsSync(keyPath)) {
+        throw new Error(`Private key file not found: ${keyPath}`);
+      }
+      config.privateKey = fs.readFileSync(keyPath, 'utf8');
+    } else if (connectionConfig.password) {
+      config.password = connectionConfig.password;
+    } else {
+      throw new Error('No authentication method provided (password or private key)');
+    }
+    
+    await this.ssh.connect(config);
+    this.connected = true;
+  }
+  
+  /**
+   * Disconnect from remote server
+   */
+  disconnect() {
+    if (this.connected) {
+      this.ssh.dispose();
+      this.connected = false;
+    }
+  }
+  
+  /**
+   * Create directories on remote server
+   * @param {string} baseDir - Base directory on remote
+   * @param {string[]} directories - Array of directory paths relative to baseDir
+   * @param {function} onProgress - Progress callback
+   */
+  async createDirectories(baseDir, directories, onProgress) {
+    // First ensure base directory exists
+    await this.ssh.execCommand(`mkdir -p "${baseDir}"`);
+    
+    for (const dir of directories) {
+      const fullPath = `${baseDir}/${dir}`;
+      await this.ssh.execCommand(`mkdir -p "${fullPath}"`);
+      if (onProgress) onProgress(dir);
+    }
+  }
+  
+  /**
+   * Upload files to remote server
+   * @param {string} baseDir - Base directory on remote
+   * @param {Array<{local: string, remote: string}>} files - File mappings
+   * @param {function} onProgress - Progress callback (receives current file index and total)
+   */
+  async uploadFiles(baseDir, files, onProgress) {
+    const total = files.length;
+    
+    for (let i = 0; i < files.length; i++) {
+      const file = files[i];
+      const remotePath = `${baseDir}/${file.remote}`;
+      
+      await this.ssh.putFile(file.local, remotePath);
+      
+      if (onProgress) {
+        onProgress(i + 1, total, file.remote);
+      }
+    }
+  }
+  
+  /**
+   * Execute a script on remote server
+   * @param {string} baseDir - Base directory on remote
+   * @param {string} scriptName - Script filename
+   * @returns {object} Execution result with stdout and stderr
+   */
+  async executeScript(baseDir, scriptName) {
+    const scriptPath = `${baseDir}/${scriptName}`;
+    
+    // First check if script exists
+    const checkResult = await this.ssh.execCommand(`test -f "${scriptPath}" && echo "exists"`);
+    if (!checkResult.stdout.includes('exists')) {
+      throw new Error(`Script not found: ${scriptPath}`);
+    }
+    
+    // Make script executable
+    await this.ssh.execCommand(`chmod +x "${scriptPath}"`);
+    
+    // Execute script
+    const result = await this.ssh.execCommand(`cd "${baseDir}" && bash "${scriptPath}"`, {
+      cwd: baseDir
+    });
+    
+    return result;
+  }
+  
+  /**
+   * Check if remote directory exists
+   * @param {string} dir - Directory path
+   * @returns {boolean}
+   */
+  async directoryExists(dir) {
+    const result = await this.ssh.execCommand(`test -d "${dir}" && echo "exists"`);
+    return result.stdout.includes('exists');
+  }
+  
+  /**
+   * Get remote server info
+   * @returns {object} Server info
+   */
+  async getServerInfo() {
+    const hostname = await this.ssh.execCommand('hostname');
+    const os = await this.ssh.execCommand('cat /etc/os-release 2>/dev/null | grep PRETTY_NAME | cut -d= -f2 | tr -d \'"\'');
+    const uptime = await this.ssh.execCommand('uptime -p 2>/dev/null || uptime');
+    
+    return {
+      hostname: hostname.stdout.trim(),
+      os: os.stdout.trim() || 'Unknown',
+      uptime: uptime.stdout.trim()
+    };
+  }
+}
+
+module.exports = { SSHDeployer };