@wrongstack/tools 0.274.0 → 0.275.1

package/dist/test.js

@@ -268,6 +268,7 @@ var CircuitBreaker = class {
     if (this.state === "open") return;
     this.state = "open";
     this.openedAt = Date.now();
+    this.window = [];
     try {
       this.onTrip?.();
     } catch {
@@ -307,7 +308,7 @@ var SENSITIVE_FLAG_PATTERNS = [
   /--(?:token|password|passwd|pwd|secret|api[-_]?key|api[-_]?secret|auth|credential|private[-_]?key|access[-_]?key|github[-_]?token|gh[-_]?token|bearer|jwt|oauth|pin|pincode|passphrase|access[-_]?token)(?:[=\s,][^\s]*)?/gi,
   // -f "value" style short flags
   /(?<!\w)-t(?:\s+|\s*=\s*)[^\s,]+/,
-  /(?<!\w)-p(?:ssword)?(?:\s+|\s*=\s*)[^\s,]+/gi,
+  /(?<!\w)-(?:p|password)(?:\s+|\s*=\s*)[^\s,]+/gi,
   // env var–style secrets: TOKEN=x, API_KEY=y, etc.
   /(?:TOKEN|API_KEY|API_SECRET|AUTH_TOKEN|GITHUB_TOKEN|GH_TOKEN|BEARER|JWT|OAUTH|CREDENTIAL|SECRET|PRIVATE_KEY|PASSWORD|PASSWD)\s*[=:]\s*[^\s,]+/gi,
   // Generic high-entropy look: base64 strings >32 chars or hex strings >32 digits — but only
@@ -368,12 +369,35 @@ var ProcessRegistryImpl = class {
   register(info) {
     this.processes.set(info.pid, { ...info, killed: false, protected: info.protected ?? false });
   }
+  _isSafeSignalPid(pid) {
+    return Number.isInteger(pid) && pid > 1 && pid !== process.pid && pid !== process.ppid;
+  }
+  _canSignalProcessGroup(p) {
+    return os.platform() !== "win32" && p.processGroupLeader === true && this._isSafeSignalPid(p.pid) && typeof p.child.pid === "number" && p.child.pid === p.pid;
+  }
+  _killChildDirect(p, signal) {
+    try {
+      p.child.kill(signal);
+    } catch {
+    }
+  }
+  _killPosix(p, signal) {
+    if (this._canSignalProcessGroup(p)) {
+      try {
+        process.kill(-p.pid, signal);
+        return;
+      } catch {
+      }
+    }
+    this._killChildDirect(p, signal);
+  }
   /** Unregister a process by PID. Called on 'close' / 'exit' events. */
   unregister(pid) {
     this.processes.delete(pid);
   }
   /** Get a single process by PID. */
   get(pid) {
+    this._pruneStale(pid);
     return this.processes.get(pid);
   }
   /** Get all tracked processes. */
@@ -537,6 +561,7 @@ var ProcessRegistryImpl = class {
    *  Returns true if the process was found and kill was attempted.
    */
   kill(pid, opts = {}) {
+    this._pruneStale(pid);
     const p = this.processes.get(pid);
     if (!p) return false;
     if (p.killed) return true;
@@ -566,27 +591,12 @@ var ProcessRegistryImpl = class {
     }
     try {
       if (force) {
-        try {
-          process.kill(-pid, "SIGKILL");
-        } catch {
-          p.child.kill("SIGKILL");
-        }
+        this._killPosix(p, "SIGKILL");
       } else {
-        try {
-          process.kill(-pid, "SIGTERM");
-        } catch {
-          p.child.kill("SIGTERM");
-        }
+        this._killPosix(p, "SIGTERM");
         const timer = setTimeout(() => {
           if (this.processes.has(pid) && !p.child.killed) {
-            try {
-              process.kill(-pid, "SIGKILL");
-            } catch {
-              try {
-                p.child.kill("SIGKILL");
-              } catch {
-              }
-            }
+            this._killPosix(p, "SIGKILL");
           }
         }, graceMs);
         timer.unref?.();
@@ -621,6 +631,34 @@ var ProcessRegistryImpl = class {
     }
     return killed;
   }
+  /**
+   * Check whether a tracked process entry is stale — the child has exited
+   * (exitCode !== null) AND it's been in the registry long enough that the
+   * OS may have reused the PID for a new, unrelated process.
+   *
+   * P3 #24 (before-release.md): on POSIX, PIDs are reused after process
+   * exit. If a tracked process exits but its 'close' event hasn't fired yet
+   * (or was missed), the registry still holds the entry. A new process
+   * gets the same PID, and PID-based lookups (get, kill, shouldBlockKill)
+   * may incorrectly protect or target the wrong process.
+   *
+   * The 60s threshold is conservative — the OS typically waits much longer
+   * before reusing a PID, but we want to clean up before that becomes a risk.
+   */
+  _isStaleEntry(entry) {
+    return entry.child.exitCode !== null && Date.now() - entry.startedAt > 6e4;
+  }
+  /**
+   * Remove a stale entry for a specific PID before any PID-based lookup.
+   * This prevents PID reuse from causing the registry to act on a dead
+   * process that has been replaced by a new one with the same PID.
+   */
+  _pruneStale(pid) {
+    const entry = this.processes.get(pid);
+    if (entry && this._isStaleEntry(entry)) {
+      this.processes.delete(pid);
+    }
+  }
 };
 var _registry;
 function getProcessRegistry() {