feat: Add dependency cooldown for npm packages (#200)

* feat: Add dependency cooldown for npm packages

Strip recently-published package versions from npm registry metadata
responses so npm's resolver naturally falls back to older versions.
Overrides the Accept header to force full packument responses (which
include the "time" field needed for publish-date checks).

Reports cooldown blocks only when all versions are stripped (remaining == 0),
matching npm's --min-release-age behavior for silent fallback.

* fix: Report oldest version in cooldown block (shortest wait)

When all versions are blocked by cooldown, report the oldest version
since it exits the cooldown window first — giving the user the
shortest wait time instead of the longest.

* fix: Handle resp.Body.Close error return for errcheck linter

* test: Add dependency cooldown assertions to template config tests

* fix: config template for dependency cooldown

* fix: Prevent npm from caching cooldown-stripped metadata responses

* fix: Restore body on ReadAll failure and log Close errors in response modifier

* fix: Close response body before replacing to prevent connection leak

* fix: Correct daysLeft ceiling math and update ContentLength on error recovery

* fix: Clear Status on status code change and update ContentLength in modifier error path

* refactor: address review comments on dependency cooldown PR

- Make NpmCooldownHandler and constructor package-private
- Pass cooldown days as parameter instead of reading config internally
- Convert standalone functions to methods on npmCooldownHandler
- Set Accept-Encoding: identity to prevent gzip responses breaking JSON parsing
- Return 503 with descriptive message when upstream body read fails

* fix: log errors in stripCooldownVersions instead of swallowing them

* fix: Config preserve fallback defaults

* fix: Code review fixes

* fix: correct cooldown tip to show wait time instead of incorrect trusted_packages advice

* fix: prevent integer overflow in cooldown duration calculation with large days values

* refactor: deduplicate CooldownBlock into internal/models, fix misleading variable names

- Move CooldownBlock struct to internal/models to eliminate duplication
  between proxy/interceptors and internal/ui packages
- Simplify proxy_flow.go by using direct assignment instead of field copy
- Rename latestStripped/latestDate to oldestVer/oldestDate for clarity

* fix: Dependency Cooldown Check Encapsulation (#207)

* fix: Encapsulate cooldown check

* feat: Add --skip-dependency-cooldown override

* fix: Code review fixes

---------

Co-authored-by: Abhisek Datta <abhisek.datta@gmail.com>

internal/ui/report.go

@@ -5,6 +5,7 @@ import (
 	"time"
 
 	"github.com/safedep/pmg/analyzer"
+	"github.com/safedep/pmg/internal/models"
 )
 
 // FlowType indicates which execution flow was used
@@ -78,6 +79,9 @@ type ReportData struct {
 	BlockedPackages   []*analyzer.PackageVersionAnalysisResult
 	ConfirmedPackages []*analyzer.PackageVersionAnalysisResult
 
+	// Packages blocked by the dependency cooldown policy (proxy mode only)
+	CooldownBlockedPackages []models.CooldownBlock
+
 	// Configuration context
 	FlowType          FlowType
 	DryRun            bool
@@ -106,7 +110,7 @@ func (r *ReportData) Finalize() {
 
 // HasIssues returns true if any packages were blocked or required confirmation
 func (r *ReportData) HasIssues() bool {
-	return r.BlockedCount > 0 || r.ConfirmedCount > 0
+	return r.BlockedCount > 0 || r.ConfirmedCount > 0 || len(r.CooldownBlockedPackages) > 0
 }
 
 // WasSuccessful returns true if execution completed without blocks or errors
@@ -172,15 +176,33 @@ func reportNormal(data *ReportData) {
 
 	switch data.Outcome {
 	case OutcomeBlocked:
-		fmt.Println()
-		fmt.Printf("%s %s\n", Colors.Red("✗"), Colors.Red("Malicious package blocked"))
+		if len(data.BlockedPackages) > 0 {
+			fmt.Println()
+			fmt.Printf("%s %s\n", Colors.Red("✗"), Colors.Red("Malicious package blocked"))
+			printMaliciousPackagesList(data.BlockedPackages)
+			fmt.Println()
+		}
 
-		printMaliciousPackagesList(data.BlockedPackages)
-		fmt.Println()
+		if len(data.CooldownBlockedPackages) > 0 {
+			fmt.Println()
+			n := len(data.CooldownBlockedPackages)
+			fmt.Printf("%s %s\n",
+				Colors.Yellow("⊘"),
+				Colors.Yellow(fmt.Sprintf("Dependency cooldown — %s blocked", pluralizePackages(n))))
+			printCooldownPackagesList(data.CooldownBlockedPackages)
+			fmt.Println()
+		}
 
-		icon = Colors.Red("✗")
-		message = fmt.Sprintf("PMG: %d packages analyzed, %d blocked",
-			data.TotalAnalyzed, data.BlockedCount)
+		onlyCooldown := len(data.BlockedPackages) == 0 && len(data.CooldownBlockedPackages) > 0
+		if onlyCooldown {
+			icon = Colors.Yellow("⊘")
+			message = fmt.Sprintf("PMG: %s analyzed, %s blocked by cooldown",
+				pluralizePackages(data.TotalAnalyzed), pluralizePackages(data.BlockedCount))
+		} else {
+			icon = Colors.Red("✗")
+			message = fmt.Sprintf("PMG: %d packages analyzed, %d blocked",
+				data.TotalAnalyzed, data.BlockedCount)
+		}
 	case OutcomeUserCancelled:
 		icon = Colors.Yellow("✗")
 		message = fmt.Sprintf("PMG: %d packages analyzed, installation cancelled",
@@ -265,6 +287,26 @@ func reportVerbose(data *ReportData) {
 		}
 	}
 
+	if len(data.CooldownBlockedPackages) > 0 {
+		fmt.Println()
+		fmt.Println(Colors.Yellow("  Blocked by dependency cooldown:"))
+		for _, pkg := range data.CooldownBlockedPackages {
+			dateStr := ""
+			if !pkg.PublishDate.IsZero() {
+				dateStr = fmt.Sprintf(" (%s)", pkg.PublishDate.Format("2006-01-02"))
+			}
+			fmt.Printf("    %s %s\n", Colors.Yellow("⊘"), Colors.Yellow(fmt.Sprintf("%s@%s", pkg.Name, pkg.Version)))
+			fmt.Printf("      %s\n", Colors.Dim(fmt.Sprintf(
+				"Published %s ago%s — cooldown: %d days, available in %s",
+				pluralizeDays(pkg.DaysAgo), dateStr, pkg.CooldownDays, pluralizeDays(pkg.DaysLeft),
+			)))
+			fmt.Printf("      %s\n", Colors.Dim(fmt.Sprintf(
+				"Tip: wait %s for cooldown to expire",
+				pluralizeDays(pkg.DaysLeft),
+			)))
+		}
+	}
+
 	fmt.Println()
 }
 
@@ -273,7 +315,16 @@ func printOutcomeLine(data *ReportData) {
 	case OutcomeSuccess:
 		fmt.Printf("  %s %s\n", Colors.Green("✓"), Colors.Green("Installation completed successfully"))
 	case OutcomeBlocked:
-		fmt.Printf("  %s %s\n", Colors.Red("✗"), Colors.Red("Installation blocked - malicious package detected"))
+		hasMalware := len(data.BlockedPackages) > 0
+		hasCooldown := len(data.CooldownBlockedPackages) > 0
+		switch {
+		case hasMalware && hasCooldown:
+			fmt.Printf("  %s %s\n", Colors.Red("✗"), Colors.Red("Installation blocked — malicious package detected + cooldown policy"))
+		case hasCooldown:
+			fmt.Printf("  %s %s\n", Colors.Yellow("⊘"), Colors.Yellow("Installation blocked — dependency cooldown policy"))
+		default:
+			fmt.Printf("  %s %s\n", Colors.Red("✗"), Colors.Red("Installation blocked — malicious package detected"))
+		}
 	case OutcomeUserCancelled:
 		fmt.Printf("  %s %s\n", Colors.Yellow("✗"), Colors.Yellow("Installation cancelled by user"))
 	case OutcomeDryRun: