awesome-slash 2.4.4 → 2.5.1

package/plugins/deslop-around/lib/platform/detect-platform.js

@@ -11,43 +11,118 @@
  */
 
 const fs = require('fs');
-const { execSync, exec } = require('child_process');
+const path = require('path');
+const { exec } = require('child_process');
 const { promisify } = require('util');
 
 const execAsync = promisify(exec);
 const fsPromises = fs.promises;
 
-// Detection cache for performance (platform rarely changes during session)
-let _cachedDetection = null;
-let _cacheExpiry = 0;
-const CACHE_TTL_MS = 60000; // 1 minute cache
+// Import shared utilities
+const { CacheManager } = require('../utils/cache-manager');
+const {
+  CI_CONFIGS,
+  DEPLOYMENT_CONFIGS,
+  PACKAGE_MANAGER_CONFIGS
+} = require('./detection-configs');
 
-// File read cache to avoid reading the same file multiple times (#17)
-const _fileCache = new Map();
-const _existsCache = new Map();
+/**
+ * Default timeout for async operations (5 seconds)
+ */
+const DEFAULT_ASYNC_TIMEOUT_MS = 5000;
 
 /**
- * Check if a file exists (cached)
- * @param {string} filepath - Path to check
- * @returns {boolean}
+ * Maximum JSON file size to parse (1MB) - prevents DoS via large files
  */
-function existsCached(filepath) {
-  if (_existsCache.has(filepath)) {
-    return _existsCache.get(filepath);
+const MAX_JSON_SIZE_BYTES = 1024 * 1024;
+
+/**
+ * Safely parse JSON content with size limit
+ * @param {string} content - JSON string to parse
+ * @param {string} filename - Filename for error messages
+ * @returns {Object|null} Parsed object or null if invalid/too large
+ */
+function safeJSONParse(content, filename = 'unknown') {
+  if (!content || typeof content !== 'string') {
+    return null;
+  }
+  if (content.length > MAX_JSON_SIZE_BYTES) {
+    return null;
+  }
+  try {
+    return JSON.parse(content);
+  } catch {
+    return null;
   }
-  const exists = fs.existsSync(filepath);
-  _existsCache.set(filepath, exists);
-  return exists;
 }
 
 /**
- * Check if a file exists (cached, async)
+ * Wrap a promise with a timeout
+ * @param {Promise} promise - Promise to wrap
+ * @param {number} timeoutMs - Timeout in milliseconds
+ * @param {string} operation - Operation name for error message
+ * @returns {Promise} Promise that rejects on timeout
+ */
+function withTimeout(promise, timeoutMs = DEFAULT_ASYNC_TIMEOUT_MS, operation = 'operation') {
+  let timeoutId;
+  const timeoutPromise = new Promise((_, reject) => {
+    timeoutId = setTimeout(() => {
+      reject(new Error(`${operation} timed out after ${timeoutMs}ms`));
+    }, timeoutMs);
+  });
+
+  return Promise.race([promise, timeoutPromise]).finally(() => {
+    clearTimeout(timeoutId);
+  });
+}
+
+/**
+ * Execute a command with timeout protection
+ * @param {string} cmd - Command to execute
+ * @param {Object} options - exec options
+ * @param {number} timeoutMs - Timeout in milliseconds
+ * @returns {Promise<{stdout: string, stderr: string}>}
+ */
+async function execWithTimeout(cmd, options = {}, timeoutMs = DEFAULT_ASYNC_TIMEOUT_MS) {
+  return withTimeout(execAsync(cmd, options), timeoutMs, `exec: ${cmd.substring(0, 50)}`);
+}
+
+// Maximum cached file size constant
+const MAX_CACHED_FILE_SIZE = 64 * 1024; // 64KB max per cached file
+
+// Cache instances using CacheManager abstraction
+const _detectionCache = new CacheManager({ maxSize: 1, ttl: 60000 });
+const _fileCache = new CacheManager({ maxSize: 100, ttl: 60000, maxValueSize: MAX_CACHED_FILE_SIZE });
+const _existsCache = new CacheManager({ maxSize: 100, ttl: 60000 });
+
+/**
+ * Generic file-based detector
+ * @param {Array} configs - Array of {file, platform} objects
+ * @param {Function} existsChecker - Async function to check file existence
+ * @returns {Promise<string|null>} Detected platform or null
+ */
+async function detectFromFiles(configs, existsChecker) {
+  const checks = await Promise.all(
+    configs.map(({ file }) => existsChecker(file))
+  );
+
+  for (let i = 0; i < checks.length; i++) {
+    if (checks[i]) {
+      return configs[i].platform;
+    }
+  }
+  return null;
+}
+
+/**
+ * Check if a file exists (cached)
  * @param {string} filepath - Path to check
  * @returns {Promise<boolean>}
  */
-async function existsCachedAsync(filepath) {
-  if (_existsCache.has(filepath)) {
-    return _existsCache.get(filepath);
+async function existsCached(filepath) {
+  const cached = _existsCache.get(filepath);
+  if (cached !== undefined) {
+    return cached;
   }
   try {
     await fsPromises.access(filepath);
@@ -61,142 +136,58 @@ async function existsCachedAsync(filepath) {
 
 /**
  * Read file contents (cached)
- * @param {string} filepath - Path to read
- * @returns {string|null}
- */
-function readFileCached(filepath) {
-  if (_fileCache.has(filepath)) {
-    return _fileCache.get(filepath);
-  }
-  try {
-    const content = fs.readFileSync(filepath, 'utf8');
-    _fileCache.set(filepath, content);
-    return content;
-  } catch {
-    _fileCache.set(filepath, null);
-    return null;
-  }
-}
-
-/**
- * Read file contents (cached, async)
+ * Only caches files smaller than MAX_CACHED_FILE_SIZE to prevent memory bloat
+ * Optimized: normalizes filepath to prevent cache pollution from variant paths
  * @param {string} filepath - Path to read
  * @returns {Promise<string|null>}
  */
-async function readFileCachedAsync(filepath) {
-  if (_fileCache.has(filepath)) {
-    return _fileCache.get(filepath);
+async function readFileCached(filepath) {
+  const normalizedPath = path.resolve(filepath);
+
+  const cached = _fileCache.get(normalizedPath);
+  if (cached !== undefined) {
+    return cached;
   }
   try {
-    const content = await fsPromises.readFile(filepath, 'utf8');
-    _fileCache.set(filepath, content);
+    const content = await fsPromises.readFile(normalizedPath, 'utf8');
+    _fileCache.set(normalizedPath, content);
     return content;
   } catch {
-    _fileCache.set(filepath, null);
+    _fileCache.set(normalizedPath, null);
     return null;
   }
 }
 
 /**
  * Detects CI platform by scanning for configuration files
- * @returns {string|null} CI platform name or null if not detected
- */
-function detectCI() {
-  if (existsCached('.github/workflows')) return 'github-actions';
-  if (existsCached('.gitlab-ci.yml')) return 'gitlab-ci';
-  if (existsCached('.circleci/config.yml')) return 'circleci';
-  if (existsCached('Jenkinsfile')) return 'jenkins';
-  if (existsCached('.travis.yml')) return 'travis';
-  return null;
-}
-
-/**
- * Detects CI platform by scanning for configuration files (async)
  * @returns {Promise<string|null>} CI platform name or null if not detected
  */
-async function detectCIAsync() {
-  const checks = await Promise.all([
-    existsCachedAsync('.github/workflows'),
-    existsCachedAsync('.gitlab-ci.yml'),
-    existsCachedAsync('.circleci/config.yml'),
-    existsCachedAsync('Jenkinsfile'),
-    existsCachedAsync('.travis.yml')
-  ]);
-
-  if (checks[0]) return 'github-actions';
-  if (checks[1]) return 'gitlab-ci';
-  if (checks[2]) return 'circleci';
-  if (checks[3]) return 'jenkins';
-  if (checks[4]) return 'travis';
-  return null;
+async function detectCI() {
+  return detectFromFiles(CI_CONFIGS, existsCached);
 }
 
 /**
  * Detects deployment platform by scanning for platform-specific files
- * @returns {string|null} Deployment platform name or null if not detected
- */
-function detectDeployment() {
-  if (existsCached('railway.json') || existsCached('railway.toml')) return 'railway';
-  if (existsCached('vercel.json')) return 'vercel';
-  if (existsCached('netlify.toml') || existsCached('.netlify')) return 'netlify';
-  if (existsCached('fly.toml')) return 'fly';
-  if (existsCached('.platform.sh')) return 'platform-sh';
-  if (existsCached('render.yaml')) return 'render';
-  return null;
-}
-
-/**
- * Detects deployment platform by scanning for platform-specific files (async)
  * @returns {Promise<string|null>} Deployment platform name or null if not detected
  */
-async function detectDeploymentAsync() {
-  const checks = await Promise.all([
-    existsCachedAsync('railway.json'),
-    existsCachedAsync('railway.toml'),
-    existsCachedAsync('vercel.json'),
-    existsCachedAsync('netlify.toml'),
-    existsCachedAsync('.netlify'),
-    existsCachedAsync('fly.toml'),
-    existsCachedAsync('.platform.sh'),
-    existsCachedAsync('render.yaml')
-  ]);
-
-  if (checks[0] || checks[1]) return 'railway';
-  if (checks[2]) return 'vercel';
-  if (checks[3] || checks[4]) return 'netlify';
-  if (checks[5]) return 'fly';
-  if (checks[6]) return 'platform-sh';
-  if (checks[7]) return 'render';
-  return null;
+async function detectDeployment() {
+  return detectFromFiles(DEPLOYMENT_CONFIGS, existsCached);
 }
 
 /**
  * Detects project type by scanning for language-specific files
- * @returns {string} Project type identifier
- */
-function detectProjectType() {
-  if (existsCached('package.json')) return 'nodejs';
-  if (existsCached('requirements.txt') || existsCached('pyproject.toml') || existsCached('setup.py')) return 'python';
-  if (existsCached('Cargo.toml')) return 'rust';
-  if (existsCached('go.mod')) return 'go';
-  if (existsCached('pom.xml') || existsCached('build.gradle')) return 'java';
-  return 'unknown';
-}
-
-/**
- * Detects project type by scanning for language-specific files (async)
  * @returns {Promise<string>} Project type identifier
  */
-async function detectProjectTypeAsync() {
+async function detectProjectType() {
   const checks = await Promise.all([
-    existsCachedAsync('package.json'),
-    existsCachedAsync('requirements.txt'),
-    existsCachedAsync('pyproject.toml'),
-    existsCachedAsync('setup.py'),
-    existsCachedAsync('Cargo.toml'),
-    existsCachedAsync('go.mod'),
-    existsCachedAsync('pom.xml'),
-    existsCachedAsync('build.gradle')
+    existsCached('package.json'),
+    existsCached('requirements.txt'),
+    existsCached('pyproject.toml'),
+    existsCached('setup.py'),
+    existsCached('Cargo.toml'),
+    existsCached('go.mod'),
+    existsCached('pom.xml'),
+    existsCached('build.gradle')
   ]);
 
   if (checks[0]) return 'nodejs';
@@ -209,103 +200,24 @@ async function detectProjectTypeAsync() {
 
 /**
  * Detects package manager by scanning for lockfiles
- * @returns {string|null} Package manager name or null if not detected
- */
-function detectPackageManager() {
-  if (existsCached('pnpm-lock.yaml')) return 'pnpm';
-  if (existsCached('yarn.lock')) return 'yarn';
-  if (existsCached('bun.lockb')) return 'bun';
-  if (existsCached('package-lock.json')) return 'npm';
-  if (existsCached('poetry.lock')) return 'poetry';
-  if (existsCached('Pipfile.lock')) return 'pipenv';
-  if (existsCached('Cargo.lock')) return 'cargo';
-  if (existsCached('go.sum')) return 'go';
-  return null;
-}
-
-/**
- * Detects package manager by scanning for lockfiles (async)
  * @returns {Promise<string|null>} Package manager name or null if not detected
  */
-async function detectPackageManagerAsync() {
-  const checks = await Promise.all([
-    existsCachedAsync('pnpm-lock.yaml'),
-    existsCachedAsync('yarn.lock'),
-    existsCachedAsync('bun.lockb'),
-    existsCachedAsync('package-lock.json'),
-    existsCachedAsync('poetry.lock'),
-    existsCachedAsync('Pipfile.lock'),
-    existsCachedAsync('Cargo.lock'),
-    existsCachedAsync('go.sum')
-  ]);
-
-  if (checks[0]) return 'pnpm';
-  if (checks[1]) return 'yarn';
-  if (checks[2]) return 'bun';
-  if (checks[3]) return 'npm';
-  if (checks[4]) return 'poetry';
-  if (checks[5]) return 'pipenv';
-  if (checks[6]) return 'cargo';
-  if (checks[7]) return 'go';
-  return null;
+async function detectPackageManager() {
+  return detectFromFiles(
+    PACKAGE_MANAGER_CONFIGS.map(({ file, manager }) => ({ file, platform: manager })),
+    existsCached
+  );
 }
 
 /**
  * Detects branch strategy (single-branch vs multi-branch with dev+prod)
- * @returns {string} 'single-branch' or 'multi-branch'
- */
-function detectBranchStrategy() {
-  try {
-    // Check both local and remote branches
-    const localBranches = execSync('git branch', { encoding: 'utf8', stdio: ['pipe', 'pipe', 'ignore'] });
-    let remoteBranches = '';
-    try {
-      remoteBranches = execSync('git branch -r', { encoding: 'utf8', stdio: ['pipe', 'pipe', 'ignore'] });
-    } catch {}
-
-    const allBranches = localBranches + remoteBranches;
-
-    const hasStable = allBranches.includes('stable');
-    const hasProduction = allBranches.includes('production') || allBranches.includes('prod');
-
-    if (hasStable || hasProduction) {
-      return 'multi-branch'; // dev + prod workflow
-    }
-
-    // Check deployment configs for multi-environment setup (uses cache)
-    if (existsCached('railway.json')) {
-      try {
-        const content = readFileCached('railway.json');
-        if (content) {
-          const config = JSON.parse(content);
-          // Validate JSON structure before accessing properties
-          if (config &&
-              typeof config === 'object' &&
-              typeof config.environments === 'object' &&
-              config.environments !== null &&
-              Object.keys(config.environments).length > 1) {
-            return 'multi-branch';
-          }
-        }
-      } catch {}
-    }
-
-    return 'single-branch'; // main only
-  } catch {
-    return 'single-branch';
-  }
-}
-
-/**
- * Detects branch strategy (single-branch vs multi-branch with dev+prod) (async)
  * @returns {Promise<string>} 'single-branch' or 'multi-branch'
  */
-async function detectBranchStrategyAsync() {
+async function detectBranchStrategy() {
   try {
-    // Run git commands in parallel
     const [localResult, remoteResult] = await Promise.all([
-      execAsync('git branch', { encoding: 'utf8' }).catch(() => ({ stdout: '' })),
-      execAsync('git branch -r', { encoding: 'utf8' }).catch(() => ({ stdout: '' }))
+      execWithTimeout('git branch', { encoding: 'utf8' }).catch(() => ({ stdout: '' })),
+      execWithTimeout('git branch -r', { encoding: 'utf8' }).catch(() => ({ stdout: '' }))
     ]);
 
     const allBranches = (localResult.stdout || '') + (remoteResult.stdout || '');
@@ -317,12 +229,11 @@ async function detectBranchStrategyAsync() {
       return 'multi-branch';
     }
 
-    // Check deployment configs for multi-environment setup (uses cache)
-    if (await existsCachedAsync('railway.json')) {
+    if (await existsCached('railway.json')) {
       try {
-        const content = await readFileCachedAsync('railway.json');
+        const content = await readFileCached('railway.json');
         if (content) {
-          const config = JSON.parse(content);
+          const config = safeJSONParse(content, 'railway.json');
           if (config &&
               typeof config === 'object' &&
               typeof config.environments === 'object' &&
@@ -342,43 +253,15 @@ async function detectBranchStrategyAsync() {
 
 /**
  * Detects the main branch name
- * @returns {string} Main branch name ('main' or 'master')
- */
-function detectMainBranch() {
-  try {
-    const defaultBranch = execSync('git symbolic-ref refs/remotes/origin/HEAD', {
-      encoding: 'utf8',
-      stdio: ['pipe', 'pipe', 'ignore']
-    })
-      .trim()
-      .replace('refs/remotes/origin/', '');
-    return defaultBranch;
-  } catch {
-    // Fallback: check common names
-    try {
-      execSync('git rev-parse --verify main', {
-        encoding: 'utf8',
-        stdio: ['pipe', 'pipe', 'ignore']
-      });
-      return 'main';
-    } catch {
-      return 'master';
-    }
-  }
-}
-
-/**
- * Detects the main branch name (async)
  * @returns {Promise<string>} Main branch name ('main' or 'master')
  */
-async function detectMainBranchAsync() {
+async function detectMainBranch() {
   try {
-    const { stdout } = await execAsync('git symbolic-ref refs/remotes/origin/HEAD', { encoding: 'utf8' });
+    const { stdout } = await execWithTimeout('git symbolic-ref refs/remotes/origin/HEAD', { encoding: 'utf8' });
     return stdout.trim().replace('refs/remotes/origin/', '');
   } catch {
-    // Fallback: check common names
     try {
-      await execAsync('git rev-parse --verify main', { encoding: 'utf8' });
+      await execWithTimeout('git rev-parse --verify main', { encoding: 'utf8' });
       return 'main';
     } catch {
       return 'master';
@@ -387,50 +270,19 @@ async function detectMainBranchAsync() {
 }
 
 /**
- * Main detection function - aggregates all platform information (sync)
- * Uses caching to avoid repeated filesystem/git operations
- * @param {boolean} forceRefresh - Force cache refresh
- * @returns {Object} Platform configuration object
- */
-function detect(forceRefresh = false) {
-  const now = Date.now();
-
-  // Return cached result if still valid
-  if (!forceRefresh && _cachedDetection && now < _cacheExpiry) {
-    return _cachedDetection;
-  }
-
-  _cachedDetection = {
-    ci: detectCI(),
-    deployment: detectDeployment(),
-    projectType: detectProjectType(),
-    packageManager: detectPackageManager(),
-    branchStrategy: detectBranchStrategy(),
-    mainBranch: detectMainBranch(),
-    hasPlanFile: existsCached('PLAN.md'),
-    hasTechDebtFile: existsCached('TECHNICAL_DEBT.md'),
-    timestamp: new Date(now).toISOString()
-  };
-  _cacheExpiry = now + CACHE_TTL_MS;
-
-  return _cachedDetection;
-}
-
-/**
- * Main detection function - aggregates all platform information (async)
+ * Main detection function - aggregates all platform information
  * Uses Promise.all for parallel execution and caching
  * @param {boolean} forceRefresh - Force cache refresh
  * @returns {Promise<Object>} Platform configuration object
  */
-async function detectAsync(forceRefresh = false) {
-  const now = Date.now();
-
-  // Return cached result if still valid
-  if (!forceRefresh && _cachedDetection && now < _cacheExpiry) {
-    return _cachedDetection;
+async function detect(forceRefresh = false) {
+  if (!forceRefresh) {
+    const cached = _detectionCache.get('detection');
+    if (cached !== undefined) {
+      return cached;
+    }
   }
 
-  // Run all detections in parallel
   const [
     ci,
     deployment,
@@ -441,17 +293,17 @@ async function detectAsync(forceRefresh = false) {
     hasPlanFile,
     hasTechDebtFile
   ] = await Promise.all([
-    detectCIAsync(),
-    detectDeploymentAsync(),
-    detectProjectTypeAsync(),
-    detectPackageManagerAsync(),
-    detectBranchStrategyAsync(),
-    detectMainBranchAsync(),
-    existsCachedAsync('PLAN.md'),
-    existsCachedAsync('TECHNICAL_DEBT.md')
+    detectCI(),
+    detectDeployment(),
+    detectProjectType(),
+    detectPackageManager(),
+    detectBranchStrategy(),
+    detectMainBranch(),
+    existsCached('PLAN.md'),
+    existsCached('TECHNICAL_DEBT.md')
   ]);
 
-  _cachedDetection = {
+  const detection = {
     ci,
     deployment,
     projectType,
@@ -460,35 +312,36 @@ async function detectAsync(forceRefresh = false) {
     mainBranch,
     hasPlanFile,
     hasTechDebtFile,
-    timestamp: new Date(now).toISOString()
+    timestamp: new Date().toISOString()
   };
-  _cacheExpiry = now + CACHE_TTL_MS;
 
-  return _cachedDetection;
+  _detectionCache.set('detection', detection);
+  return detection;
 }
 
 /**
- * Invalidate the detection cache
+ * Invalidate all detection caches
  * Call this after making changes that affect platform detection
  */
 function invalidateCache() {
-  _cachedDetection = null;
-  _cacheExpiry = 0;
+  _detectionCache.clear();
   _fileCache.clear();
   _existsCache.clear();
 }
 
-// When run directly, output JSON (uses async for better performance)
+// When run directly, output JSON
 if (require.main === module) {
   (async () => {
     try {
-      const result = await detectAsync();
-      console.log(JSON.stringify(result, null, 2));
+      const result = await detect();
+      const indent = process.stdout.isTTY ? 2 : 0;
+      console.log(JSON.stringify(result, null, indent));
     } catch (error) {
+      const indent = process.stderr.isTTY ? 2 : 0;
       console.error(JSON.stringify({
         error: error.message,
         timestamp: new Date().toISOString()
-      }, null, 2));
+      }, null, indent));
       process.exit(1);
     }
   })();
@@ -497,18 +350,11 @@ if (require.main === module) {
 // Export for use as module
 module.exports = {
   detect,
-  detectAsync,
   invalidateCache,
   detectCI,
-  detectCIAsync,
   detectDeployment,
-  detectDeploymentAsync,
   detectProjectType,
-  detectProjectTypeAsync,
   detectPackageManager,
-  detectPackageManagerAsync,
   detectBranchStrategy,
-  detectBranchStrategyAsync,
-  detectMainBranch,
-  detectMainBranchAsync
+  detectMainBranch
 };