start-command 0.37.6 → 0.37.8

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # start-command
 
+## 0.37.8
+
+### Patch Changes
+
+- 9ffcae7: A closed stdout/stderr pipe (`$ -- cmd | head -1`) no longer crashes start with an unhandled `EPIPE` and exit code 1: the command keeps running, its log and record are written, and start exits with the command's own exit code (#222).
+
+## 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.8",
   "description": "Gamification of coding, execute any command with ability to auto-report issues on GitHub",
   "main": "src/bin/cli.js",
   "exports": {

package/src/bin/cli.js

@@ -42,6 +42,17 @@ const { resolveChildExitCode } = require('../lib/exit-reason');
 const { printUsage } = require('../lib/usage');
 const { buildDisplayCommand, getCommandName } = require('../lib/shell-utils');
 
+// A closed stdout/stderr pipe (`$ --version | head -1`) must neither crash
+// start nor replace the command's exit code: drop the failed output and keep
+// running, logging and recording as usual (issue #222).
+for (const stream of [process.stdout, process.stderr]) {
+  stream.on('error', (err) => {
+    if (err.code !== 'EPIPE' && err.code !== 'ERR_STREAM_DESTROYED') {
+      throw err;
+    }
+  });
+}
+
 // Configuration from environment variables
 const config = {
   // Disable automatic issue creation (useful for testing)

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);
+}

package/test/regression-222.js

@@ -0,0 +1,61 @@
+const { describe, it, expect } = require('bun:test');
+const { spawn } = require('child_process');
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+
+const CLI = path.join(__dirname, '../src/bin/cli.js');
+
+// Run the CLI with the read ends of the given output pipes closed before it
+// starts writing, like `$ --version | head -1` once `head` has exited.
+function runWithClosedPipes(args, closed) {
+  return new Promise((resolve) => {
+    const child = spawn(process.execPath, [CLI, ...args], {
+      stdio: ['ignore', 'pipe', 'pipe'],
+      env: {
+        ...process.env,
+        START_APP_FOLDER: fs.mkdtempSync(path.join(os.tmpdir(), 'start-222-')),
+        START_DISABLE_AUTO_ISSUE: '1',
+        START_DISABLE_LOG_UPLOAD: '1',
+      },
+    });
+    let stderr = '';
+    for (const name of ['stdout', 'stderr']) {
+      if (closed.includes(name)) {
+        child[name].destroy();
+      } else {
+        child[name].on('data', (chunk) => (stderr += chunk));
+      }
+    }
+    child.on('close', (code) => resolve({ code, stderr }));
+  });
+}
+
+describe('closed output pipes (#222)', () => {
+  if (process.platform === 'win32') {
+    return;
+  }
+  const big = 'seq 1 200000';
+  for (const args of [['--version'], ['-v'], ['--help']]) {
+    it(`${args[0]} exits 0 when stdout is closed`, async () => {
+      const result = await runWithClosedPipes(args, ['stdout']);
+      expect(result.stderr).not.toContain('EPIPE');
+      expect(result.code).toBe(0);
+    }, 15000);
+  }
+  it('a command keeps its exit code when stdout is closed', async () => {
+    const result = await runWithClosedPipes(
+      ['--', 'sh', '-c', `${big}; exit 3`],
+      ['stdout']
+    );
+    expect(result.stderr).not.toContain('EPIPE');
+    expect(result.code).toBe(3);
+  }, 15000);
+  it('a command keeps its exit code when stdout and stderr are closed', async () => {
+    const result = await runWithClosedPipes(
+      ['--', 'sh', '-c', `${big}; ${big} >&2; exit 3`],
+      ['stdout', 'stderr']
+    );
+    expect(result.code).toBe(3);
+  }, 15000);
+});