@bli-cockpit/cli 0.2.281 → 0.2.283

package/dist/memory-guard-script-windows.js

@@ -0,0 +1,144 @@
+import { MEMORY_GUARD_KIND_PATTERNS, MEMORY_GUARD_LOG_KEEP_LINES, MEMORY_GUARD_LOG_LIMIT_BYTES, MEMORY_GUARD_ORPHAN_MIN_AGE_SECONDS, } from "./memory-guard-contract.js";
+import { powershellLiteral } from "./autostart-windows-scripts.js";
+/**
+ * The Windows memory guard (BLI-23571): a resident PowerShell loop behind the same hidden wscript launcher
+ * the sync job uses. Windows has no `top -o mem` footprint, so the analogue is PrivateMemorySize64 (the
+ * commit charge, which counts pages swapped to the pagefile). Pressure comes from free physical memory:
+ * under 10% free is a warning, under 5% is critical, read at most every 10 s. Only `node` processes are
+ * touched, never the guard's own PID. Orphaned vitest workers (parent PID no longer alive, command line
+ * contains `vitest`, older than 5 minutes) are reaped once a minute through Win32_Process.
+ *
+ * Same log contract as the macOS guard: one JSON line per decision, a kind label and a sha256 prefix of
+ * the command line, never the command line. NOT proven on a real Windows host from this repo's CI: the
+ * rendering is tested, the live behaviour is not.
+ */
+export function renderWindowsMemoryGuardScript(options) {
+    const kindChecks = MEMORY_GUARD_KIND_PATTERNS.map(([kind, pattern]) => `  if ($Command -match ${powershellLiteral(pattern)}) { return '${kind}' }`);
+    return [
+        "$ErrorActionPreference = 'Continue'",
+        `$limitMb = ${options.limits.hard}`,
+        `$warnLimitMb = ${options.limits.warning}`,
+        `$criticalLimitMb = ${options.limits.critical}`,
+        `$orphanMinAgeSeconds = ${MEMORY_GUARD_ORPHAN_MIN_AGE_SECONDS}`,
+        `$logPath = ${powershellLiteral(options.logPath)}`,
+        `$logLimitBytes = ${MEMORY_GUARD_LOG_LIMIT_BYTES}`,
+        `$logKeepLines = ${MEMORY_GUARD_LOG_KEEP_LINES}`,
+        "# One resident copy per user session; a second instance leaves quietly.",
+        "$guardMutex = New-Object System.Threading.Mutex($false, 'Local\\BLICockpitMemoryGuard')",
+        "if (-not $guardMutex.WaitOne(0)) { exit 0 }",
+        "",
+        "function Write-GuardLog([string]$EventName, [int]$ProcessId, [int]$FootprintMb, [int]$LimitMb, [string]$Reason, [string]$Kind, [string]$Sha) {",
+        "  $ts = (Get-Date).ToUniversalTime().ToString('yyyy-MM-ddTHH:mm:ssZ')",
+        '  $line = \'{"ts":"\' + $ts + \'","event":"\' + $EventName + \'","pid":\' + $ProcessId + \',"footprint_mb":\' + $FootprintMb + \',"limit_mb":\' + $LimitMb + \',"reason":"\' + $Reason + \'","kind":"\' + $Kind + \'","cmd_sha256":"\' + $Sha + \'"}\'',
+        "  Add-Content -LiteralPath $logPath -Encoding UTF8 -Value $line",
+        "}",
+        "",
+        "# The coarse label for a command line. The same table as the macOS guard and the CLI's tests.",
+        "function Get-GuardKind([string]$Command) {",
+        ...kindChecks,
+        "  return 'other'",
+        "}",
+        "",
+        "function Get-GuardSha([string]$Command) {",
+        "  $sha = [System.Security.Cryptography.SHA256]::Create()",
+        "  $bytes = $sha.ComputeHash([System.Text.Encoding]::UTF8.GetBytes($Command))",
+        "  return (($bytes | ForEach-Object { $_.ToString('x2') }) -join '').Substring(0, 12)",
+        "}",
+        "",
+        "function Stop-Runaway($Process, [int]$FootprintMb, [int]$LimitMb, [string]$Reason) {",
+        "  if ($Process.Id -eq $PID) { return }",
+        "  $command = ''",
+        "  try { $command = [string](Get-CimInstance Win32_Process -Filter \"ProcessId=$($Process.Id)\" -ErrorAction Stop).CommandLine } catch { $command = '' } # an unreadable command line only loses the kind label (other)",
+        "  $kind = Get-GuardKind $command",
+        "  $sha = Get-GuardSha $command",
+        "  try {",
+        "    Stop-Process -Id $Process.Id -Force -ErrorAction Stop",
+        "    Write-GuardLog 'killed' $Process.Id $FootprintMb $LimitMb $Reason $kind $sha",
+        "  } catch {",
+        "    Write-GuardLog 'kill_failed' $Process.Id $FootprintMb $LimitMb $Reason $kind $sha",
+        "  }",
+        "}",
+        "",
+        "# 1 normal, 2 warning (<10% free physical memory), 4 critical (<5%).",
+        "function Get-PressureLevel {",
+        "  try {",
+        "    $os = Get-CimInstance Win32_OperatingSystem -ErrorAction Stop",
+        "    $freePercent = ($os.FreePhysicalMemory / $os.TotalVisibleMemorySize) * 100",
+        "    if ($freePercent -lt 5) { return 4 }",
+        "    if ($freePercent -lt 10) { return 2 }",
+        "  } catch { return 1 } # pressure unreadable: judge by the normal limit",
+        "  return 1",
+        "}",
+        "",
+        "function Remove-OrphanVitest {",
+        "  $alive = @{}",
+        "  Get-Process -ErrorAction SilentlyContinue | ForEach-Object { $alive[[int]$_.Id] = $true }",
+        "  $now = Get-Date",
+        "  Get-CimInstance Win32_Process -Filter \"Name='node.exe'\" -ErrorAction SilentlyContinue | ForEach-Object {",
+        "    if ($_.ProcessId -eq $PID) { return }",
+        "    if (-not $_.CommandLine -or $_.CommandLine -notmatch 'vitest') { return }",
+        "    if ($alive.ContainsKey([int]$_.ParentProcessId)) { return }",
+        "    if (-not $_.CreationDate -or ($now - $_.CreationDate).TotalSeconds -lt $orphanMinAgeSeconds) { return }",
+        "    try {",
+        "      Stop-Process -Id $_.ProcessId -Force -ErrorAction Stop",
+        "      Write-GuardLog 'orphan_reaped' $_.ProcessId 0 0 'orphan_vitest_worker' (Get-GuardKind $_.CommandLine) (Get-GuardSha $_.CommandLine)",
+        "    } catch {",
+        "      Write-GuardLog 'kill_failed' $_.ProcessId 0 0 'orphan_vitest_worker' (Get-GuardKind $_.CommandLine) (Get-GuardSha $_.CommandLine)",
+        "    }",
+        "  }",
+        "}",
+        "",
+        "function Limit-GuardLog {",
+        "  $file = Get-Item -LiteralPath $logPath -ErrorAction SilentlyContinue",
+        "  if ($file -and $file.Length -gt $logLimitBytes) {",
+        "    $keep = Get-Content -LiteralPath $logPath -Tail $logKeepLines",
+        "    Set-Content -LiteralPath $logPath -Value $keep -Encoding UTF8",
+        "  }",
+        "}",
+        "",
+        "New-Item -ItemType Directory -Force -Path (Split-Path -Parent $logPath) | Out-Null",
+        "Write-GuardLog 'started' $PID 0 $limitMb 'started' 'guard' ''",
+        "$level = 1",
+        "$lastPressure = [DateTime]::MinValue",
+        "$lastOrphan = Get-Date",
+        "while ($true) {",
+        "  $now = Get-Date",
+        "  if (($now - $lastPressure).TotalSeconds -ge 10) { $level = Get-PressureLevel; $lastPressure = $now }",
+        "  $limit = $limitMb; $footprintReason = 'footprint_over_limit'",
+        "  if ($level -ge 4) { $limit = $criticalLimitMb; $footprintReason = 'pressure_critical' }",
+        "  elseif ($level -ge 2) { $limit = $warnLimitMb; $footprintReason = 'pressure_warning' }",
+        "  foreach ($p in @(Get-Process -Name node -ErrorAction SilentlyContinue)) {",
+        "    $workingMb = [int]($p.WorkingSet64 / 1MB)",
+        "    $privateMb = [int]($p.PrivateMemorySize64 / 1MB)",
+        "    if ($workingMb -gt $limit) { Stop-Runaway $p $workingMb $limit 'rss_over_limit' }",
+        "    elseif ($privateMb -gt $limit) { Stop-Runaway $p $privateMb $limit $footprintReason }",
+        "  }",
+        "  if (($now - $lastOrphan).TotalSeconds -ge 60) { Remove-OrphanVitest; Limit-GuardLog; $lastOrphan = $now }",
+        "  Start-Sleep -Seconds 5",
+        "}",
+        "",
+    ].join("\r\n");
+}
+/**
+ * Registers the guard as a logon task that restarts on failure, has no execution time limit, and starts
+ * immediately. Any older resident copy is stopped first so a re-install runs the new script, not the old.
+ */
+export function renderWindowsMemoryGuardRegistration(options) {
+    return [
+        "$ErrorActionPreference = 'Stop'",
+        `$taskName = ${powershellLiteral(options.taskName)}`,
+        `$launcherPath = ${powershellLiteral(options.launcherPath)}`,
+        "$wscriptPath = Join-Path (Join-Path $env:SystemRoot 'System32') 'wscript.exe'",
+        "$identity = [System.Security.Principal.WindowsIdentity]::GetCurrent().Name",
+        "$action = New-ScheduledTaskAction -Execute $wscriptPath -Argument ('//B \"' + $launcherPath + '\"')",
+        "$trigger = New-ScheduledTaskTrigger -AtLogOn -User $identity",
+        "$principal = New-ScheduledTaskPrincipal -UserId $identity -LogonType Interactive -RunLevel Limited",
+        "$settings = New-ScheduledTaskSettingsSet -AllowStartIfOnBatteries -DontStopIfGoingOnBatteries -StartWhenAvailable -MultipleInstances IgnoreNew -RestartCount 999 -RestartInterval (New-TimeSpan -Minutes 1) -ExecutionTimeLimit (New-TimeSpan -Seconds 0)",
+        "Register-ScheduledTask -TaskName $taskName -Action $action -Trigger $trigger -Principal $principal -Settings $settings -Force | Out-Null",
+        `# A running older copy keeps the old limits and script: stop it, then start the registered one.`,
+        "Stop-ScheduledTask -TaskName $taskName -ErrorAction SilentlyContinue",
+        `Get-CimInstance Win32_Process -Filter "Name='powershell.exe'" -ErrorAction SilentlyContinue | Where-Object { $_.CommandLine -like '*${options.scriptName}*' -and $_.ProcessId -ne $PID } | ForEach-Object { Stop-Process -Id $_.ProcessId -Force -ErrorAction SilentlyContinue }`,
+        "Start-ScheduledTask -TaskName $taskName",
+        "",
+    ].join("\r\n");
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bli-cockpit/cli",
-  "version": "0.2.281",
+  "version": "0.2.283",
   "private": false,
   "type": "module",
   "bin": {
@@ -28,7 +28,7 @@
   },
   "dependencies": {
     "@bli-cockpit/memory-mcp": "0.1.88",
-    "@bli-cockpit/mcp": "0.1.171",
+    "@bli-cockpit/mcp": "0.1.172",
     "@bli-cockpit/telemetry-core": "0.1.94",
     "unpdf": "1.8.1"
   },