opencode-api-security-testing 4.0.1 → 5.2.0

package/src/utils/env-checker.ts

@@ -0,0 +1,264 @@
+/**
+ * Environment Checker & Auto-Installer
+ * 
+ * Detects missing dependencies and installs them automatically.
+ * Supports: Python, pip packages, Playwright, Node.js modules
+ */
+
+import { execSync } from "child_process";
+import { existsSync } from "fs";
+import { join } from "path";
+
+export interface EnvCheckResult {
+  python: boolean;
+  pythonVersion: string | null;
+  pip: boolean;
+  playwright: boolean;
+  playwrightInstalled: boolean;
+  missingPackages: string[];
+  autoInstalled: string[];
+  errors: string[];
+}
+
+/**
+ * Run shell command safely
+ */
+function runCommand(cmd: string, timeout = 30000): { success: boolean; output: string; error: string } {
+  try {
+    const output = execSync(cmd, { 
+      encoding: "utf-8", 
+      timeout,
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    return { success: true, output: output.trim(), error: "" };
+  } catch (error) {
+    const err = error as { stdout?: string; stderr?: string; message?: string };
+    return { 
+      success: false, 
+      output: err.stdout || "", 
+      error: err.stderr || err.message || "Unknown error" 
+    };
+  }
+}
+
+/**
+ * Check if Python is available
+ */
+function checkPython(): { available: boolean; version: string | null } {
+  // Try python3 first, then python
+  for (const cmd of ["python3 --version", "python --version"]) {
+    const result = runCommand(cmd, 5000);
+    if (result.success) {
+      const versionMatch = result.output.match(/Python\s+(\d+\.\d+\.\d+)/i) || 
+                           result.error.match(/Python\s+(\d+\.\d+\.\d+)/i);
+      return { 
+        available: true, 
+        version: versionMatch ? versionMatch[1] : "unknown" 
+      };
+    }
+  }
+  return { available: false, version: null };
+}
+
+/**
+ * Check if pip is available
+ */
+function checkPip(): boolean {
+  for (const cmd of ["pip3 --version", "pip --version", "python3 -m pip --version", "python -m pip --version"]) {
+    const result = runCommand(cmd, 5000);
+    if (result.success) return true;
+  }
+  return false;
+}
+
+/**
+ * Check if a Python package is installed
+ */
+function checkPythonPackage(packageName: string): boolean {
+  const result = runCommand(`python3 -c "import ${packageName}" 2>/dev/null || python -c "import ${packageName}" 2>/dev/null`, 5000);
+  return result.success;
+}
+
+/**
+ * Install a Python package
+ */
+function installPythonPackage(packageName: string): { success: boolean; error: string } {
+  for (const cmd of [
+    `pip3 install -q ${packageName}`,
+    `pip install -q ${packageName}`,
+    `python3 -m pip install -q ${packageName}`,
+    `python -m pip install -q ${packageName}`
+  ]) {
+    const result = runCommand(cmd, 60000);
+    if (result.success) return { success: true, error: "" };
+  }
+  return { success: false, error: `Failed to install ${packageName}` };
+}
+
+/**
+ * Check if Playwright browsers are installed
+ */
+function checkPlaywright(): { installed: boolean; browsersInstalled: boolean } {
+  // Check if playwright Python package is installed
+  const hasPackage = checkPythonPackage("playwright");
+  
+  // Check if browsers are installed
+  const homeDir = process.env.HOME || process.env.USERPROFILE || "/root";
+  const pwCachePath = join(homeDir, ".cache", "ms-playwright");
+  const browsersInstalled = existsSync(pwCachePath);
+  
+  return { installed: hasPackage, browsersInstalled };
+}
+
+/**
+ * Install Playwright
+ */
+function installPlaywright(): { success: boolean; error: string } {
+  console.log("[env-checker] Installing Playwright Python package...");
+  const pkgResult = installPythonPackage("playwright");
+  if (!pkgResult.success) return pkgResult;
+  
+  console.log("[env-checker] Installing Playwright browsers (chromium)...");
+  const browserResult = runCommand("python3 -m playwright install chromium", 300000);
+  if (browserResult.success) {
+    return { success: true, error: "" };
+  }
+  
+  // Try with python fallback
+  const browserResult2 = runCommand("python -m playwright install chromium", 300000);
+  if (browserResult2.success) {
+    return { success: true, error: "" };
+  }
+  
+  return { success: false, error: `Failed to install Playwright browsers: ${browserResult.error}` };
+}
+
+/**
+ * Check if Node.js is available
+ */
+function checkNode(): { available: boolean; version: string | null } {
+  const result = runCommand("node --version", 5000);
+  if (result.success) {
+    return { available: true, version: result.output };
+  }
+  return { available: false, version: null };
+}
+
+/**
+ * Run full environment check and auto-install missing dependencies
+ */
+export function checkAndFixEnvironment(): EnvCheckResult {
+  const result: EnvCheckResult = {
+    python: false,
+    pythonVersion: null,
+    pip: false,
+    playwright: false,
+    playwrightInstalled: false,
+    missingPackages: [],
+    autoInstalled: [],
+    errors: []
+  };
+  
+  console.log("[env-checker] Starting environment check...");
+  
+  // Check Python
+  const pythonCheck = checkPython();
+  result.python = pythonCheck.available;
+  result.pythonVersion = pythonCheck.version;
+  
+  if (!result.python) {
+    result.errors.push("Python 3 is not installed. Please install Python 3.8+ from https://python.org");
+    return result;
+  }
+  
+  console.log(`[env-checker] Python ${result.pythonVersion} detected`);
+  
+  // Check pip
+  result.pip = checkPip();
+  if (!result.pip) {
+    result.errors.push("pip is not available. Please install pip.");
+    return result;
+  }
+  
+  // Check required Python packages
+  const requiredPackages = ["requests", "beautifulsoup4"];
+  const optionalPackages = ["playwright", "websocket-client", "urllib3"];
+  
+  for (const pkg of requiredPackages) {
+    if (!checkPythonPackage(pkg)) {
+      console.log(`[env-checker] Installing missing package: ${pkg}`);
+      const installResult = installPythonPackage(pkg);
+      if (installResult.success) {
+        result.autoInstalled.push(pkg);
+        console.log(`[env-checker] ✓ ${pkg} installed`);
+      } else {
+        result.missingPackages.push(pkg);
+        result.errors.push(`Failed to install ${pkg}: ${installResult.error}`);
+      }
+    }
+  }
+  
+  // Check optional packages
+  for (const pkg of optionalPackages) {
+    if (!checkPythonPackage(pkg)) {
+      console.log(`[env-checker] Installing optional package: ${pkg}`);
+      const installResult = installPythonPackage(pkg);
+      if (installResult.success) {
+        result.autoInstalled.push(pkg);
+        console.log(`[env-checker] ✓ ${pkg} installed`);
+      } else {
+        result.missingPackages.push(pkg);
+      }
+    }
+  }
+  
+  // Check Playwright
+  const pwCheck = checkPlaywright();
+  result.playwright = pwCheck.installed;
+  result.playwrightInstalled = pwCheck.browsersInstalled;
+  
+  if (!pwCheck.installed || !pwCheck.browsersInstalled) {
+    console.log("[env-checker] Playwright not fully installed, installing...");
+    const pwInstallResult = installPlaywright();
+    if (pwInstallResult.success) {
+      result.playwright = true;
+      result.playwrightInstalled = true;
+      result.autoInstalled.push("playwright+browsers");
+      console.log("[env-checker] ✓ Playwright installed");
+    } else {
+      result.errors.push(`Playwright installation failed: ${pwInstallResult.error}`);
+      console.log(`[env-checker] ⚠ Playwright installation failed: ${pwInstallResult.error}`);
+      console.log("[env-checker] browser_collect tool will not work until Playwright is installed");
+    }
+  }
+  
+  // Summary
+  console.log("\n[env-checker] Environment check complete:");
+  console.log(`  Python: ${result.python ? "✓ " + result.pythonVersion : "✗"}`);
+  console.log(`  pip: ${result.pip ? "✓" : "✗"}`);
+  console.log(`  Playwright: ${result.playwrightInstalled ? "✓" : "✗"}`);
+  if (result.autoInstalled.length > 0) {
+    console.log(`  Auto-installed: ${result.autoInstalled.join(", ")}`);
+  }
+  if (result.errors.length > 0) {
+    console.log(`  Errors: ${result.errors.join("; ")}`);
+  }
+  
+  return result;
+}
+
+/**
+ * Generate a shell command prefix that ensures dependencies are installed
+ */
+export function getDepCheckCommand(ctx: { directory: string }): string {
+  const { existsSync } = require("fs");
+  const { join } = require("path");
+  
+  const skillPath = join(ctx.directory, "skills/api-security-testing");
+  const reqFile = join(skillPath, "requirements.txt");
+  
+  if (existsSync(reqFile)) {
+    return `pip install -q -r "${reqFile}" 2>/dev/null; `;
+  }
+  return "";
+}