start-command 0.35.4 → 0.37.0

package/test/regression-189.js

@@ -0,0 +1,224 @@
+const { it, expect } = require('bun:test');
+const { parseArgs } = require('../src/lib/args-parser');
+it('CPU penalty is opt-in and accepts durations and percentage settings', () => {
+  const options = parseArgs([
+    '--isolated',
+    'docker',
+    '--cpu-penalty',
+    '--cpu-penalty-trigger-window',
+    '1s',
+    '--',
+    'true',
+  ]).wrapperOptions;
+  expect(options.cpuPenaltyConfig.triggerWindowMs).toBe(1000);
+  expect(options.cpuPenaltyConfig.release).toBe(65);
+});
+const { initialState, evaluate, average } = require('../src/lib/cpu-penalty');
+const config = {
+  cpus: 2,
+  trigger: 95,
+  triggerWindowMs: 100,
+  release: 65,
+  releaseWindowMs: 100,
+};
+it('requires complete time-weighted windows, then lifts and observes afresh', () => {
+  let state = initialState(null, 0);
+  const tick = (now, cores) => {
+    const result = evaluate(
+      state,
+      { now, cores, daemonCpus: 6, maxGapMs: 50 },
+      config
+    );
+    state = result.state;
+    return result.action;
+  };
+  expect(tick(0, 6)).toBeNull();
+  expect(tick(40, 6)).toBeNull();
+  expect(tick(80, 6)).toBeNull();
+  expect(tick(100, 0.4).kind).toBe('apply');
+  expect(state.penaltyCount).toBe(1);
+  expect(tick(120, 0.4)).toBeNull();
+  expect(tick(160, 0.4)).toBeNull();
+  expect(tick(200, 0.4)).toBeNull();
+  expect(tick(220, 6).kind).toBe('lift');
+  expect(state.penalizedMs).toBe(120);
+  expect(tick(240, 6)).toBeNull();
+  expect(tick(280, 6)).toBeNull();
+  expect(tick(320, 6)).toBeNull();
+  expect(tick(340, 6).kind).toBe('apply');
+  expect(state.penaltyCount).toBe(2);
+});
+it('resets coverage on outage, gaps, resize and restart, and skips ineffective caps', () => {
+  let state = initialState(4, 0);
+  for (const [now, cores, daemonCpus] of [
+    [0, 4, 6],
+    [40, 4, 6],
+    [80, NaN, 6],
+    [120, 4, 6],
+    [160, 4, 6],
+    [200, 4, 8],
+  ]) {
+    const result = evaluate(
+      state,
+      { now, cores, daemonCpus, maxGapMs: 50 },
+      config
+    );
+    state = result.state;
+    expect(result.action).toBeNull();
+  }
+  const restarted = initialState(4, 240, state);
+  expect(
+    evaluate(
+      restarted,
+      { now: 240, cores: 4, daemonCpus: 8, maxGapMs: 50 },
+      config
+    ).action
+  ).toBeNull();
+  expect(
+    evaluate(state, { now: 400, cores: 4, daemonCpus: 8, maxGapMs: 50 }, config)
+      .action
+  ).toBeNull();
+  state = initialState(1, 0);
+  for (const now of [0, 40, 80, 120]) {
+    const r = evaluate(
+      state,
+      { now, cores: 1, daemonCpus: 6, maxGapMs: 50 },
+      config
+    );
+    state = r.state;
+    expect(r.action).toBeNull();
+  }
+});
+it('weights timestamps rather than giving short intervals equal weight', () => {
+  expect(
+    average(
+      [
+        { at: 0, cores: 6 },
+        { at: 90, cores: 0 },
+        { at: 100, cores: 0 },
+      ],
+      100,
+      100
+    )
+  ).toBe(5.4);
+});
+it('resume restores the original base within resized daemon capacity', () => {
+  const { prepareResumeResources } = require('../src/lib/resume-resources');
+  const record = {
+    options: {
+      isolated: 'docker',
+      sessionName: 'task',
+      cpuPenaltyConfig: config,
+      baseResourceLimits: ['--cpus=3'],
+      resourceLimits: ['--cpus=0.5'],
+      resolvedLimits: { cpus: 3 },
+    },
+  };
+  const result = prepareResumeResources(
+    record,
+    { state: 'stopped' },
+    {},
+    (_cmd, args) => ({
+      success: true,
+      stdout: JSON.stringify(
+        args[0] === 'info'
+          ? { MemTotal: 1073741824, NCPU: 2 }
+          : { NanoCpus: 500000000 }
+      ),
+    })
+  );
+  expect(result.resourceLimits).toContain('--cpus=2');
+  expect(result.resolvedLimits.cpus).toBe(2);
+  expect(record.options.baseResourceLimits).toEqual(['--cpus=3']);
+});
+
+it('monitor applies, lifts and reapplies with tracking disabled', () => {
+  if (process.platform === 'win32') {
+    return;
+  }
+  const fs = require('fs'),
+    path = require('path'),
+    os = require('os');
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'cpu-monitor-189-'));
+  try {
+    const logPath = path.join(dir, 'task.log');
+    fs.writeFileSync(logPath, '');
+    const record = {
+      logPath,
+      options: {
+        sessionName: 'cpu-task',
+        cpuPenaltyConfig: {
+          ...config,
+          triggerWindowMs: 200,
+          releaseWindowMs: 200,
+        },
+        baseResourceLimits: [],
+      },
+    };
+    const result = require('child_process').spawnSync(
+      '/bin/sh',
+      [
+        path.resolve(__dirname, '../../experiments/issue-195-cpu-monitor.sh'),
+        process.execPath,
+        require.resolve('../src/lib/cpu-penalty-monitor'),
+        '',
+        'cpu-task',
+        '1',
+        JSON.stringify(record),
+      ],
+      { encoding: 'utf8' }
+    );
+    expect(result.status).toBe(0);
+    const lines = fs.readFileSync(logPath, 'utf8').trim().split('\n');
+    expect(lines.length).toBe(3);
+    expect(lines[0]).toContain('CPU penalty applied: 2');
+    expect(lines[1]).toContain('CPU penalty lifted: 6');
+    expect(lines[2]).toContain('CPU penalty applied: 2');
+    const state = JSON.parse(
+      fs.readFileSync(`${logPath}.cpu-penalty.json`, 'utf8')
+    );
+    expect(state.penaltyCount).toBe(2);
+    expect(state.phase).toBe('penalized');
+    expect(state.penalizedMs).toBeGreaterThan(200);
+  } finally {
+    fs.rmSync(dir, { recursive: true, force: true });
+  }
+}, 15000);
+
+it('preserves legacy CPU quota format and the lower original base', () => {
+  const limits = require('../src/lib/docker-resource-limits');
+  const base = ['--cpu-period=200000', '--cpu-quota=100000'];
+  expect(limits.cpuCount(base)).toBe(0.5);
+  expect(limits.withCpuLimit(base, 0.25)).toEqual([
+    '--cpu-period=100000',
+    '--cpu-quota=25000',
+  ]);
+  expect(limits.cpuUpdateArgs(base, 0.25)).toEqual([
+    '--cpu-period=100000',
+    '--cpu-quota=25000',
+  ]);
+  const { clampCpuToDaemon } = require('../src/lib/resume-resources');
+  expect(
+    clampCpuToDaemon(base, () => ({
+      success: true,
+      stdout: '{"NCPU":4,"MemTotal":1073741824}',
+    }))
+  ).toEqual(['--cpu-period=100000', '--cpu-quota=50000']);
+  const { prepareResumeResources } = require('../src/lib/resume-resources');
+  const overridden = prepareResumeResources(
+    {
+      options: {
+        isolated: 'docker',
+        sessionName: 'task',
+        resourceLimits: base,
+      },
+    },
+    { state: 'stopped' },
+    { cpus: '0.25' },
+    () => ({ success: true, stdout: '{"CpuPeriod":200000,"CpuQuota":100000}' })
+  );
+  expect(overridden.resourceLimits).toEqual([
+    '--cpu-period=100000',
+    '--cpu-quota=25000',
+  ]);
+});

package/test/regression-190.js

@@ -0,0 +1,111 @@
+const { describe, it, expect } = require('bun:test');
+const { parseArgs } = require('../src/lib/args-parser');
+
+describe('issue #190: launch resource options', () => {
+  it('recognizes resource flags and rejects invalid input before launch', () => {
+    const parsed = parseArgs([
+      '--isolated',
+      'docker',
+      '--image',
+      'alpine',
+      '--memory',
+      '90%-100%',
+      '--cpus=50%',
+      '--',
+      'true',
+    ]);
+    expect(parsed.wrapperOptions.memory).toBe('90%-100%');
+    expect(parsed.wrapperOptions.cpus).toBe('50%');
+    for (const value of ['100%-90%', '101%', '0%', '0g', '3watts']) {
+      expect(() =>
+        parseArgs([
+          '--isolated',
+          'docker',
+          '--image',
+          'alpine',
+          '--memory',
+          value,
+          '--',
+          'true',
+        ])
+      ).toThrow();
+    }
+  });
+});
+
+const {
+  resolveResourceOptions,
+} = require('../src/lib/docker-resource-options');
+it('uses daemon capacity, draws each range once and disables extra swap by default', () => {
+  let draws = 0;
+  const calls = [];
+  const result = resolveResourceOptions(
+    { memory: '70%-80%', cpus: '50%' },
+    (_cmd, args) => {
+      calls.push(args);
+      return {
+        success: true,
+        stdout: JSON.stringify({ MemTotal: 1024 ** 3 * 10, NCPU: 8 }),
+      };
+    },
+    () => {
+      draws++;
+      return 0.5;
+    }
+  );
+  expect(result.resourceLimits).toEqual([
+    '--memory=8053063680',
+    '--cpus=4',
+    '--memory-swap=8053063680',
+  ]);
+  expect(result.resolvedLimits.memorySwap).toBe(result.resolvedLimits.memory);
+  expect(calls).toHaveLength(1);
+  expect(draws).toBe(2);
+});
+it('preserves stored resolutions without another random draw or daemon query', () => {
+  const limits = [
+    '--memory=8053063680',
+    '--memory-swap=8053063680',
+    '--cpus=4',
+  ];
+  const result = resolveResourceOptions(
+    { resourceLimits: limits },
+    () => {
+      throw Error('unexpected query');
+    },
+    () => {
+      throw Error('unexpected draw');
+    }
+  );
+  expect(result.resourceLimits).toEqual(limits);
+});
+it('rejects swap below memory and daemon capacity failures', () => {
+  expect(() =>
+    resolveResourceOptions({ memory: '64m', memorySwap: '32m' })
+  ).toThrow();
+  expect(() =>
+    resolveResourceOptions({ memory: '80%' }, () => ({ success: false }))
+  ).toThrow();
+});
+
+it('forwards raw resource and penalty options through every remaining Docker level', () => {
+  const { buildNextLevelCommand } = require('../src/lib/command-builder');
+  const options = parseArgs([
+    '--isolated',
+    'screen docker',
+    '--memory',
+    '70%-80%',
+    '--cpus',
+    '50%',
+    '--cpu-penalty',
+    '--cpu-penalty-trigger-window',
+    '2s',
+    '--',
+    'work',
+  ]).wrapperOptions;
+  const command = buildNextLevelCommand(options, 'work');
+  const words = require('../src/lib/shell-utils').splitShellWords(command);
+  expect(words[words.indexOf('--memory') + 1]).toBe('70%-80%');
+  expect(words[words.indexOf('--cpus') + 1]).toBe('50%');
+  expect(command).toContain('--cpu-penalty-trigger-window 2000ms');
+});

package/test/regression-191.js

@@ -0,0 +1,160 @@
+const { it, expect } = require('bun:test');
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const {
+  ExecutionStore,
+  ExecutionRecord,
+} = require('../src/lib/execution-store');
+const { resumeExecution } = require('../src/lib/execution-resume');
+const { recoverKilledExecution } = require('../src/lib/execution-recovery');
+const { SessionState } = require('../src/lib/session-probe');
+
+function fixture() {
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'memory-191-'));
+  const store = new ExecutionStore({ appFolder: dir, useLinks: false });
+  const record = new ExecutionRecord({
+    command: 'work',
+    status: 'executed',
+    logPath: path.join(dir, 'run.log'),
+    options: {
+      isolated: 'docker',
+      isolationMode: 'detached',
+      sessionName: 'task',
+      image: 'alpine',
+      onKillResume: 3,
+      onKillResumeMemory: '70%-80%',
+    },
+  });
+  store.save(record);
+  const calls = [];
+  const runner = (_, args) => {
+    calls.push(args);
+    if (args[0] === 'info') {
+      return {
+        success: true,
+        stdout: JSON.stringify({
+          MemTotal: 1073741824,
+          NCPU: 4,
+          DockerRootDir: os.tmpdir(),
+        }),
+      };
+    }
+    if (args.includes('--size')) {
+      return { success: true, stdout: '1024' };
+    }
+    if (args[0] === 'inspect') {
+      return {
+        success: true,
+        stdout: JSON.stringify({
+          Memory: 67108864,
+          MemorySwap: 67108864,
+          NanoCpus: 3000000000,
+        }),
+      };
+    }
+    return { success: true, stdout: 'id' };
+  };
+  return { dir, store, record, runner, calls };
+}
+it('manual in-place memory override updates before start and records the resolution', async () => {
+  const f = fixture();
+  try {
+    const result = await resumeExecution(f.store, f.record.uuid, {
+      resourceOptions: { memory: '128m' },
+      runner: f.runner,
+      probe: () => ({ alive: false, state: SessionState.STOPPED }),
+      startWatcher: () => true,
+    });
+    expect(result.success).toBe(true);
+    const update = f.calls.find((a) => a[0] === 'update');
+    expect(update).toContain('--memory=134217728');
+    expect(update).toContain('--memory-swap=134217728');
+    expect(f.calls.indexOf(update)).toBeLessThan(
+      f.calls.findIndex((a) => a[0] === 'start')
+    );
+    expect(f.store.get(f.record.uuid).options.resolvedLimits.memory).toBe(
+      134217728
+    );
+  } finally {
+    fs.rmSync(f.dir, { recursive: true, force: true });
+  }
+});
+it('manual snapshot override applies limits to the new container at creation', async () => {
+  const f = fixture();
+  try {
+    const result = await resumeExecution(f.store, f.record.uuid, {
+      command: 'new',
+      snapshotOptions: { freeBytes: () => 100 * 1024 ** 3 },
+      resourceOptions: { memory: '128m' },
+      runner: f.runner,
+      probe: () => ({ alive: false, state: SessionState.STOPPED }),
+      startWatcher: () => true,
+    });
+    expect(result.success).toBe(true);
+    expect(f.calls.find((a) => a[0] === 'run')).toContain('--memory=134217728');
+  } finally {
+    fs.rmSync(f.dir, { recursive: true, force: true });
+  }
+});
+for (const [exitCode, oomKilled, sample, change] of [
+  [137, true, '67108864 66000000 1 1 100 100', true],
+  [137, true, '67108864 66000000 1 1 0 100', false],
+  [137, false, '67108864 66000000 0 0 0 100', false],
+  [1, true, '67108864 66000000 1 1 100 100', false],
+]) {
+  it(`automatic memory change requires a qualifying OOM (exit=${exitCode}, fresh=${change})`, () => {
+    const f = fixture();
+    try {
+      const result = recoverKilledExecution({
+        store: f.store,
+        executionId: f.record.uuid,
+        exitCode,
+        oomKilled,
+        cgroupMemory: sample,
+        finishedAt: '1970-01-01T00:01:40Z',
+        runner: f.runner,
+        random: () => 0.5,
+        startWatcher: () => true,
+      });
+      const update = f.calls.find((a) => a[0] === 'update');
+      expect(Boolean(update)).toBe(change);
+      if (change) {
+        expect(result.recovered).toBe(true);
+        expect(update).toContain('--memory=805306368');
+        expect(f.calls.indexOf(update)).toBeLessThan(
+          f.calls.findIndex((a) => a[0] === 'start')
+        );
+        expect(f.store.get(f.record.uuid).options.resolvedLimits.memory).toBe(
+          805306368
+        );
+      }
+      if (exitCode === 1) {
+        expect(result.recovered).toBe(false);
+      }
+    } finally {
+      fs.rmSync(f.dir, { recursive: true, force: true });
+    }
+  });
+}
+
+it('a failed memory update prevents starting the old-limit command', async () => {
+  const f = fixture();
+  try {
+    const result = await resumeExecution(f.store, f.record.uuid, {
+      resourceOptions: { memory: '128m' },
+      runner: (cmd, args) =>
+        args[0] === 'update'
+          ? (f.calls.push(args),
+            { success: false, stderr: 'daemon rejected update' })
+          : f.runner(cmd, args),
+      probe: () => ({ alive: false, state: SessionState.STOPPED }),
+      startWatcher: () => true,
+    });
+    expect(result.success).toBe(false);
+    expect(f.calls.some((args) => args[0] === 'start')).toBe(false);
+    expect(f.store.get(f.record.uuid).status).toBe('executed');
+  } finally {
+    fs.rmSync(f.dir, { recursive: true, force: true });
+  }
+});

package/test/regression-192.js

@@ -0,0 +1,66 @@
+const { it, expect } = require('bun:test');
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const { spawnSync } = require('child_process');
+const {
+  buildCgroupSamplerStartSnippet,
+  buildCgroupMemoryLogSnippet,
+} = require('../src/lib/cgroup-memory');
+it('samples remote/private cgroups through Docker and reports unavailable counters', () => {
+  expect(buildCgroupSamplerStartSnippet('remote-task')).toContain(
+    'docker exec'
+  );
+  expect(buildCgroupMemoryLogSnippet("'/tmp/log'")).toContain('unavailable');
+  expect(buildCgroupSamplerStartSnippet('remote-task')).toContain(
+    'HostConfig.Memory'
+  );
+});
+
+for (const mode of ['remote', 'no-shell', 'outage', 'shared']) {
+  it(`real watcher shell: ${mode}`, () => {
+    if (process.platform === 'win32') {
+      return;
+    }
+    const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'remote-192-'));
+    try {
+      const script = path.join(dir, 'sample.sh');
+      fs.writeFileSync(
+        script,
+        [
+          buildCgroupSamplerStartSnippet('remote-task'),
+          'sleep 1.2',
+          require('../src/lib/cgroup-memory').buildCgroupSamplerStopSnippet(),
+          buildCgroupMemoryLogSnippet('"$TMPDIR/memory.log"'),
+          'cat "$TMPDIR/memory.log"',
+        ].join('; ')
+      );
+      const result = spawnSync(
+        '/bin/sh',
+        [
+          path.resolve(
+            __dirname,
+            '../../experiments/issue-195-memory-sampler.sh'
+          ),
+          mode,
+          script,
+        ],
+        { encoding: 'utf8' }
+      );
+      expect(result.status).toBe(0);
+      if (mode === 'remote' || mode === 'outage') {
+        expect(result.stdout).toContain(
+          'memory.max=67108864 memory.peak=33554432 oom=1 oom_kill=3'
+        );
+      } else {
+        expect(result.stdout).toContain('Memory:     unavailable');
+        expect(result.stdout).toContain('memory.limit=67108864 (HostConfig)');
+        expect(result.stdout).toContain(
+          mode === 'no-shell' ? 'sh: not found' : 'namespace=host'
+        );
+      }
+    } finally {
+      fs.rmSync(dir, { recursive: true, force: true });
+    }
+  }, 10000);
+}