Feat/upgrade openclaw (#729)

electron/gateway/restart-governor.ts

@@ -2,79 +2,60 @@ export type RestartDecision =
   | { allow: true }
   | {
     allow: false;
-    reason: 'circuit_open' | 'budget_exceeded' | 'cooldown_active';
+    reason: 'cooldown_active';
     retryAfterMs: number;
   };
 
 type RestartGovernorOptions = {
-  maxRestartsPerWindow: number;
-  windowMs: number;
-  baseCooldownMs: number;
-  maxCooldownMs: number;
-  circuitOpenMs: number;
-  stableResetMs: number;
+  /** Minimum interval between consecutive restarts (ms). */
+  cooldownMs: number;
 };
 
 const DEFAULT_OPTIONS: RestartGovernorOptions = {
-  maxRestartsPerWindow: 4,
-  windowMs: 10 * 60 * 1000,
-  baseCooldownMs: 2500,
-  maxCooldownMs: 2 * 60 * 1000,
-  circuitOpenMs: 10 * 60 * 1000,
-  stableResetMs: 2 * 60 * 1000,
+  cooldownMs: 2500,
 };
 
+/**
+ * Lightweight restart rate-limiter.
+ *
+ * Prevents rapid-fire restarts by enforcing a simple cooldown between
+ * consecutive restart executions.  Nothing more — no circuit breakers,
+ * no sliding-window budgets, no exponential back-off.  Those mechanisms
+ * were previously present but removed because:
+ *
+ * 1. The root causes of infinite restart loops (stale ownedPid, port
+ *    contention, leaked WebSocket connections) have been fixed at their
+ *    source.
+ * 2. A 10-minute circuit-breaker lockout actively hurt the user
+ *    experience: legitimate config changes were silently dropped.
+ * 3. The complexity made the restart path harder to reason about during
+ *    debugging.
+ */
 export class GatewayRestartGovernor {
   private readonly options: RestartGovernorOptions;
-  private restartTimestamps: number[] = [];
-  private circuitOpenUntil = 0;
-  private consecutiveRestarts = 0;
   private lastRestartAt = 0;
-  private lastRunningAt = 0;
   private suppressedTotal = 0;
   private executedTotal = 0;
-  private static readonly MAX_COUNTER = Number.MAX_SAFE_INTEGER;
 
   constructor(options?: Partial<RestartGovernorOptions>) {
     this.options = { ...DEFAULT_OPTIONS, ...options };
   }
 
-  onRunning(now = Date.now()): void {
-    this.lastRunningAt = now;
+  /** No-op kept for interface compatibility with callers. */
+  onRunning(_now = Date.now()): void {
+    // Previously used to track "stable running" for exponential back-off
+    // reset.  No longer needed with the simplified cooldown model.
   }
 
   decide(now = Date.now()): RestartDecision {
-    this.pruneOld(now);
-    this.maybeResetConsecutive(now);
-
-    if (now < this.circuitOpenUntil) {
-      this.suppressedTotal = this.incrementCounter(this.suppressedTotal);
-      return {
-        allow: false,
-        reason: 'circuit_open',
-        retryAfterMs: this.circuitOpenUntil - now,
-      };
-    }
-
-    if (this.restartTimestamps.length >= this.options.maxRestartsPerWindow) {
-      this.circuitOpenUntil = now + this.options.circuitOpenMs;
-      this.suppressedTotal = this.incrementCounter(this.suppressedTotal);
-      return {
-        allow: false,
-        reason: 'budget_exceeded',
-        retryAfterMs: this.options.circuitOpenMs,
-      };
-    }
-
-    const requiredCooldown = this.getCooldownMs();
     if (this.lastRestartAt > 0) {
       const sinceLast = now - this.lastRestartAt;
-      if (sinceLast < requiredCooldown) {
-        this.suppressedTotal = this.incrementCounter(this.suppressedTotal);
+      if (sinceLast < this.options.cooldownMs) {
+        this.suppressedTotal = this.safeIncrement(this.suppressedTotal);
         return {
           allow: false,
           reason: 'cooldown_active',
-          retryAfterMs: requiredCooldown - sinceLast,
+          retryAfterMs: this.options.cooldownMs - sinceLast,
         };
       }
     }
@@ -83,11 +64,8 @@ export class GatewayRestartGovernor {
   }
 
   recordExecuted(now = Date.now()): void {
-    this.executedTotal = this.incrementCounter(this.executedTotal);
+    this.executedTotal = this.safeIncrement(this.executedTotal);
     this.lastRestartAt = now;
-    this.consecutiveRestarts += 1;
-    this.restartTimestamps.push(now);
-    this.pruneOld(now);
   }
 
   getCounters(): { executedTotal: number; suppressedTotal: number } {
@@ -105,41 +83,12 @@ export class GatewayRestartGovernor {
     return {
       suppressed_total: this.suppressedTotal,
       executed_total: this.executedTotal,
-      circuit_open_until: this.circuitOpenUntil,
+      circuit_open_until: 0, // Always 0 — no circuit breaker
     };
   }
 
-  private getCooldownMs(): number {
-    const factor = Math.pow(2, Math.max(0, this.consecutiveRestarts));
-    return Math.min(this.options.baseCooldownMs * factor, this.options.maxCooldownMs);
-  }
-
-  private maybeResetConsecutive(now: number): void {
-    if (this.lastRunningAt <= 0) return;
-    if (now - this.lastRunningAt >= this.options.stableResetMs) {
-      this.consecutiveRestarts = 0;
-    }
-  }
-
-  private pruneOld(now: number): void {
-    // Detect time rewind (system clock moved backwards) and clear all
-    // time-based guard state to avoid stale lockouts.
-    if (this.restartTimestamps.length > 0 && now < this.restartTimestamps[this.restartTimestamps.length - 1]) {
-      this.restartTimestamps = [];
-      this.circuitOpenUntil = 0;
-      this.lastRestartAt = 0;
-      this.lastRunningAt = 0;
-      this.consecutiveRestarts = 0;
-      return;
-    }
-    const threshold = now - this.options.windowMs;
-    while (this.restartTimestamps.length > 0 && this.restartTimestamps[0] < threshold) {
-      this.restartTimestamps.shift();
-    }
-  }
-
-  private incrementCounter(current: number): number {
-    if (current >= GatewayRestartGovernor.MAX_COUNTER) return 0;
+  private safeIncrement(current: number): number {
+    if (current >= Number.MAX_SAFE_INTEGER) return 0;
     return current + 1;
   }
 }