start-command 0.37.6 → 0.37.7

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # start-command
 
+## 0.37.7
+
+### Patch Changes
+
+- 6499f91: `--cpu-penalty`: `penalizedMs` keeps the time since the last monitor tick when a graceful stop or a supervisor override ends a penalty, so it never decreases (#218).
+
 ## 0.37.6
 
 ### Patch Changes

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "start-command",
-  "version": "0.37.6",
+  "version": "0.37.7",
   "description": "Gamification of coding, execute any command with ability to auto-report issues on GitHub",
   "main": "src/bin/cli.js",
   "exports": {

package/src/lib/cpu-penalty-monitor.js

@@ -4,6 +4,7 @@ const path = require('path');
 const { spawnSync } = require('child_process');
 const {
   initialState,
+  accrue,
   evaluate,
   observeBase,
   transitionLog,
@@ -289,11 +290,12 @@ async function monitor(
             name,
           ]);
           if (update.success) {
+            const now = Date.now();
             state = {
-              ...state,
+              ...accrue(state, now),
               phase: 'observing',
               limitCpus: cpus,
-              since: Date.now(),
+              since: now,
             };
             log(`[start] CPU penalty lifted: ${cpus} CPUs (monitor stopped)`);
             publish();

package/src/lib/cpu-penalty.js

@@ -85,13 +85,24 @@ function initialState(baseCpus = null, now = Date.now(), saved = null) {
     capacity: null,
   };
 }
+// Penalized time counts until the phase leaves `penalized`; `--status` only
+// extrapolates while penalized, so every transition settles it first.
+function accrue(state, now) {
+  return {
+    ...state,
+    penalizedMs:
+      state.penalizedMs +
+      (state.phase === 'penalized' ? Math.max(0, now - state.lastAt) : 0),
+    lastAt: now,
+  };
+}
 // A quota different from our cap is a supervisor override, not our penalty.
 function observeBase(state, baseCpus, now) {
   if (baseCpus === state.limitCpus) {
     return state;
   }
   return {
-    ...state,
+    ...accrue(state, now),
     phase: 'observing',
     baseCpus,
     limitCpus: baseCpus,
@@ -133,11 +144,7 @@ function evaluate(
   { now, cores, daemonCpus, maxGapMs },
   config = DEFAULTS
 ) {
-  const s = { ...state, samples: [...state.samples] };
-  if (s.phase === 'penalized') {
-    s.penalizedMs += Math.max(0, now - s.lastAt);
-  }
-  s.lastAt = now;
+  const s = { ...accrue(state, now), samples: [...state.samples] };
   const capacity = Number.isFinite(daemonCpus)
     ? Math.min(s.baseCpus || Infinity, daemonCpus)
     : NaN;
@@ -197,6 +204,7 @@ module.exports = {
   validate,
   duration,
   initialState,
+  accrue,
   observeBase,
   transitionLog,
   average,

package/test/regression-218.js

@@ -0,0 +1,101 @@
+const { it, expect } = require('bun:test');
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const { spawnSync } = require('child_process');
+const {
+  initialState,
+  accrue,
+  observeBase,
+  evaluate,
+} = require('../src/lib/cpu-penalty');
+const cpu = require('../src/lib/cpu-penalty-monitor');
+
+const penalized = (lastAt) => ({
+  ...initialState(4, 0),
+  phase: 'penalized',
+  limitCpus: 2,
+  penaltyCount: 1,
+  penalizedMs: 1000,
+  lastAt,
+});
+
+it('accrue settles penalized time since the last tick', () => {
+  expect(accrue(penalized(1000), 4000)).toMatchObject({
+    penalizedMs: 4000,
+    lastAt: 4000,
+  });
+  expect(accrue(penalized(5000), 4000).penalizedMs).toBe(1000);
+  const observing = { ...penalized(1000), phase: 'observing' };
+  expect(accrue(observing, 4000).penalizedMs).toBe(1000);
+});
+
+it('a supervisor override keeps the penalized time before it', () => {
+  const state = observeBase(penalized(1000), 3, 4000);
+  expect(state.phase).toBe('observing');
+  expect(state.penalizedMs).toBe(4000);
+  const next = evaluate(state, {
+    now: 5000,
+    cores: 0,
+    daemonCpus: 6,
+    maxGapMs: 5000,
+  }).state;
+  expect(next.penalizedMs).toBe(4000);
+});
+
+for (const mode of ['graceful', 'supervise']) {
+  it(`graceful stop lifts at once and keeps penalizedMs: ${mode}`, () => {
+    if (process.platform === 'win32') {
+      return;
+    }
+    const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'cpu-monitor-218-'));
+    try {
+      const logPath = path.join(dir, 'task.log');
+      fs.writeFileSync(logPath, '');
+      const record = {
+        logPath,
+        options: {
+          sessionName: 'cpu-task',
+          isolated: 'docker',
+          // Default 15-minute windows: the monitor ticks every 30 s.
+          cpuPenaltyConfig: {
+            cpus: 2,
+            trigger: 95,
+            release: 65,
+            triggerWindowMs: 900000,
+            releaseWindowMs: 900000,
+          },
+          baseResourceLimits: [],
+        },
+      };
+      let command = [
+        process.execPath,
+        require.resolve('../src/lib/cpu-penalty-monitor'),
+        '',
+        'cpu-task',
+        '1',
+        JSON.stringify(record),
+      ];
+      if (mode === 'supervise') {
+        const script = `${cpu.startSnippet(null, 'cpu-task', 1, { ...record.options, logPath })}; read done; ${cpu.stopSnippet()}`;
+        command = ['sh', '-c', script];
+      }
+      const result = spawnSync(
+        'python3',
+        [
+          path.resolve(__dirname, '../../experiments/issue-218-monitor.py'),
+          mode,
+          logPath,
+          ...command,
+        ],
+        { encoding: 'utf8' }
+      );
+      expect(result.status, result.stderr).toBe(0);
+      expect(fs.readFileSync(logPath, 'utf8')).toContain(
+        'CPU penalty lifted: 4 CPUs (monitor stopped)'
+      );
+    } finally {
+      fs.rmSync(dir, { recursive: true, force: true });
+    }
+  }, 20000);
+}