refactor: migrate Nuclei global template execution from os/exec to Nuclei SDK for improved integration

Author: h0tak88r

internal/api/ui_api.go

@@ -33,6 +33,8 @@ import (
 	"github.com/h0tak88r/AutoAR/internal/utils"
 	"github.com/h0tak88r/AutoAR/internal/version"
 	"github.com/projectdiscovery/dnsx/libs/dnsx"
+	"github.com/projectdiscovery/nuclei/v3/pkg/output"
+	"github.com/h0tak88r/AutoAR/internal/scanner/nuclei"
 )
 
 // ─────────────────────────────────────────────────────────────────────────────
@@ -602,41 +604,20 @@ func apiRunGlobalNuclei(c *gin.Context) {
 		os.MkdirAll(outDir, 0755)
 		outPath := filepath.Join(outDir, "nuclei-global.json")
 
-		cmd := exec.Command("nuclei", "-l", tmpFile.Name(), "-t", templatePath, "-c", "50", "-silent", "-jsonl", "-o", outPath)
-		stdout, err := cmd.StdoutPipe()
-		if err != nil {
-			return fmt.Errorf("stdout pipe failed: %w", err)
-		}
-		cmd.Stderr = os.Stderr // log errors to console
-
-		if err := cmd.Start(); err != nil {
-			return fmt.Errorf("nuclei start failed: %w", err)
-		}
-
 		matches := 0
-		scanner := bufio.NewScanner(stdout)
-		for scanner.Scan() {
-			line := scanner.Text()
-			// Nuclei JSONL format
-			var res struct {
-				TemplateID string `json:"template-id"`
-				MatchedAt  string `json:"matched-at"`
-				Host       string `json:"host"`
-				Info       struct {
-					Name     string `json:"name"`
-					Severity string `json:"severity"`
-				} `json:"info"`
-			}
-			if err := json.Unmarshal([]byte(line), &res); err == nil && res.TemplateID != "" {
+		err := nuclei.RunGlobalTemplate(tmpFile.Name(), templatePath, outPath, 50, func(event *output.ResultEvent) {
+			if event != nil && event.TemplateID != "" {
 				matches++
 				msg := fmt.Sprintf("🎯 **Global Nuclei Hit!**\n**Template:** `%s` (%s)\n**Target:** `%s`\n**Severity:** `%s`",
-					res.TemplateID, res.Info.Name, res.MatchedAt, res.Info.Severity)
+					event.TemplateID, event.Info.Name, event.MatchedAt, event.Info.SeverityHolder.Severity.String())
 				utils.SendWebhookLogAsync(msg)
-				stdLog(scanID, "[VULN] %s [%s] on %s", res.Info.Name, res.Info.Severity, res.MatchedAt)
+				stdLog(scanID, "[VULN] %s [%s] on %s", event.Info.Name, event.Info.SeverityHolder.Severity.String(), event.MatchedAt)
 			}
-		}
+		})
 
-		cmd.Wait()
+		if err != nil {
+			return fmt.Errorf("nuclei SDK scan failed: %w", err)
+		}
 
 		stdLog(scanID, "[OK] Global Nuclei scan completed. Matches: %d", matches)
 		utils.SendWebhookLogAsync(fmt.Sprintf("✅ **Global Nuclei Scan Completed**\nTemplate: `%s`\nTargets: %d\nMatches: %d", templateNameForLog, totalSubs, matches))

internal/scanner/nuclei/nuclei.go

@@ -579,6 +579,74 @@ func runNucleiCommand(targetFile, templateDir string, threads int, outputFile st
 	return err
 }
 
+// RunGlobalTemplate executes a specific nuclei template against a list of targets using the SDK.
+func RunGlobalTemplate(targetFile, templatePath, outPath string, threads int, onResult func(event *nucleiOutput.ResultEvent)) error {
+	targets, err := readTargetLines(targetFile)
+	if err != nil {
+		return fmt.Errorf("failed to read targets: %w", err)
+	}
+	if len(targets) == 0 {
+		return fmt.Errorf("no targets found in %s", targetFile)
+	}
+	if err := utils.EnsureDir(filepath.Dir(outPath)); err != nil {
+		return fmt.Errorf("failed to ensure output dir: %w", err)
+	}
+	fh, err := os.Create(outPath)
+	if err != nil {
+		return fmt.Errorf("failed to create output file: %w", err)
+	}
+	defer fh.Close()
+
+	jsonWriter, err := nucleiOutput.NewWriter(
+		nucleiOutput.WithWriter(fh),
+		nucleiOutput.WithJson(true, false),
+	)
+	if err != nil {
+		return fmt.Errorf("failed to initialize JSON writer: %w", err)
+	}
+	defer jsonWriter.Close()
+
+	engine, err := nucleiSDK.NewNucleiEngineCtx(
+		context.Background(),
+		nucleiSDK.DisableUpdateCheck(),
+		nucleiSDK.WithVerbosity(nucleiSDK.VerbosityOptions{Silent: true}),
+		nucleiSDK.WithTemplatesOrWorkflows(nucleiSDK.TemplateSources{
+			Templates: []string{templatePath},
+		}),
+		nucleiSDK.WithConcurrency(nucleiSDK.Concurrency{
+			TemplateConcurrency:           max(1, min(threads, 25)),
+			HostConcurrency:               max(1, threads),
+			HeadlessHostConcurrency:       max(1, min(threads, 10)),
+			HeadlessTemplateConcurrency:   max(1, min(threads, 10)),
+			JavascriptTemplateConcurrency: max(1, min(threads, 10)),
+			TemplatePayloadConcurrency:    25,
+			ProbeConcurrency:              max(1, min(threads, 50)),
+		}),
+	)
+	if err != nil {
+		return fmt.Errorf("failed to initialize SDK: %w", err)
+	}
+	defer engine.Close()
+
+	engine.LoadTargets(targets, false)
+	writeErr := error(nil)
+	err = engine.ExecuteWithCallback(func(event *nucleiOutput.ResultEvent) {
+		if event == nil || writeErr != nil {
+			return
+		}
+		if wErr := jsonWriter.Write(event); wErr != nil {
+			writeErr = wErr
+		}
+		if onResult != nil {
+			onResult(event)
+		}
+	})
+	if writeErr != nil {
+		return writeErr
+	}
+	return err
+}
+
 func extractDomainFromURL(url string) string {
 	// Simple extraction: remove http:// or https://, then take first part before /
 	url = strings.TrimPrefix(url, "http://")