mcp-pacemaker 1.3.1 → 2.0.2

package/bin/pooling-trace.mjs

@@ -0,0 +1,218 @@
+import fs from 'node:fs';
+import { randomUUID } from 'node:crypto';
+import { join } from 'node:path';
+import { threadId } from 'node:worker_threads';
+
+export const TRACE_MAX_EVENTS = 192;
+export const TRACE_MAX_BYTES = 65536;
+export const TRACE_MAX_LINE_BYTES = 1024;
+const methods = ['apply', 'undo', 'stageApply', 'stageUndo', 'rejectStage', 'commitBatch'];
+const codes = ['NONE', 'UNKNOWN', 'ETIMEDOUT', 'EACCES', 'EPERM', 'ENOENT', 'EIO',
+  'WRITER_DEADLINE', 'WRITER_CANCELLED', 'WRITER_FAILED', 'WRITER_OUTCOME_UNKNOWN',
+  'WRITER_DEADLINE_COMMITTED', 'WRITER_BUSY', 'WRITER_CLOSED', 'REVISION_CONFLICT',
+  'IO_ERROR', 'ACCESS_DENIED', 'FILE_BUSY', 'RECOVERY_REQUIRED', 'STORE_BUSY'];
+const integer = (value) => Number.isSafeInteger(value) && value >= 0 && value <= 0xffffffff;
+const state = (value) => Number.isInteger(value) && value >= 0 && value <= 6;
+const duration = (value) => Number.isFinite(value) && Math.abs(value) <= 120000;
+const boolean = (value) => typeof value === 'boolean';
+const method = (value) => methods.includes(value);
+const code = (value) => codes.includes(value);
+const action = (value) => ['inspect-access', 'stage', 'move-no-replace'].includes(value);
+const fields = {
+  'request-start': {},
+  'body-end': { bytes: integer },
+  'response': { status: (value) => Number.isInteger(value) && value >= 100 && value <= 599 },
+  'queue-enter': { queued: integer, applying: boolean },
+  'queue-leave': {},
+  'writer-send': { method, queued: integer, cold: boolean },
+  'worker-ready': {},
+  'worker-enter': { method, state },
+  'worker-result': { state },
+  'worker-error': { code, state },
+  'writer-expire': { expired: boolean, state },
+  'writer-result': { code, state },
+  'store-start': {},
+  'store-ready': {},
+  'helper-start': { action, call: integer, timeoutMs: duration },
+  'helper-end': { action, call: integer, helperPid: integer,
+    exit: (value) => value === null || Number.isInteger(value) && Math.abs(value) <= 0xffffffff, code },
+  'publish-start': {},
+  'publish-end': {},
+  'capture-truncated': {},
+  'capture-failed': {},
+  'capture-invalid': {},
+};
+const base = ['version', 'event', 'operation', 'pid', 'thread', 'sequence', 'elapsedMs', 'remainingMs'];
+const uuid = (value) => typeof value === 'string' &&
+  /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/.test(value);
+
+export function validateTraceRecord(record) {
+  if (!record ||
+      Object.getPrototypeOf(record) !== Object.prototype ||
+      !Object.hasOwn(fields, record.event)) throw new Error('Invalid pooling trace record.');
+  const schema = fields[record.event];
+  const keys = [...base, ...Object.keys(schema)];
+  const valid = record.version === 1 && uuid(record.operation) &&
+    integer(record.pid) && integer(record.thread) && integer(record.sequence) &&
+    record.sequence > 0 && record.sequence <= TRACE_MAX_EVENTS &&
+    duration(record.elapsedMs) && duration(record.remainingMs) &&
+    Object.keys(record).length === keys.length &&
+    keys.every((key) => Object.hasOwn(record, key)) &&
+    Object.entries(schema).every(([key, validate]) => validate(record[key]));
+  if (!valid ||
+      Buffer.byteLength(JSON.stringify(record) + '\n') > TRACE_MAX_LINE_BYTES) {
+    throw new Error('Invalid pooling trace record.');
+  }
+  return record;
+}
+
+export function traceErrorCode(error) {
+  try {
+    return error == null ? 'NONE' : codes.includes(error.code) ? error.code : 'UNKNOWN';
+  } catch {
+    return 'UNKNOWN';
+  }
+}
+
+class PoolingTraceOperation {
+  constructor(sink, deadline, context) {
+    this.sink = sink;
+    this.deadline = deadline;
+    this.context = context;
+    this.calls = 0;
+  }
+
+  helper() {
+    return ++this.calls;
+  }
+
+  record(event, extra = {}) {
+    this.sink.record(this, event, extra);
+  }
+}
+
+export class PoolingTrace {
+  #descriptor;
+  #path;
+  #identity;
+  #written = 0;
+  #owned = false;
+  #closed = false;
+
+  constructor(directory) {
+    this.directory = directory;
+    this.events = 0;
+    this.bytes = 0;
+    this.stopped = false;
+    this.failed = false;
+  }
+
+  operation(deadline, context) {
+    if (!this.directory ||
+        this.#closed) return undefined;
+    try {
+      context ??= { operation: randomUUID(), started: String(process.hrtime.bigint()), deadline: String(deadline) };
+      const valid = uuid(context.operation) &&
+        typeof context.started === 'string' && /^\d{1,24}$/.test(context.started) &&
+        typeof context.deadline === 'string' && /^\d{1,24}$/.test(context.deadline);
+      if (!valid) return undefined;
+      return new PoolingTraceOperation(this, deadline ?? BigInt(context.deadline), {
+        operation: context.operation, started: context.started, deadline: context.deadline,
+      });
+    } catch {
+      this.failed = true;
+      return undefined;
+    }
+  }
+
+  record(operation, event, extra) {
+    if (this.stopped ||
+        this.#closed) return;
+    try {
+      const now = process.hrtime.bigint();
+      const milliseconds = (value) => Math.round(Math.max(-120000, Math.min(120000, Number(value) / 1e6)) * 1000) / 1000;
+      const record = {
+        version: 1, event, operation: operation.context.operation,
+        pid: process.pid, thread: threadId, sequence: this.events + 1,
+        elapsedMs: milliseconds(now - BigInt(operation.context.started)),
+        remainingMs: milliseconds(operation.deadline - now),
+      };
+      try {
+        if (!Object.hasOwn(fields, event) ||
+            Object.keys(extra).some((key) => !Object.hasOwn(fields[event], key))) {
+          throw new Error('Invalid pooling trace fields.');
+        }
+        Object.assign(record, extra);
+        validateTraceRecord(record);
+      } catch {
+        record.event = 'capture-invalid';
+        for (const key of Object.keys(record)) {
+          if (!base.includes(key)) delete record[key];
+        }
+        this.stopped = true;
+      }
+      const full = this.events >= TRACE_MAX_EVENTS - 1 ||
+        this.bytes + Buffer.byteLength(JSON.stringify(record) + '\n') > TRACE_MAX_BYTES - TRACE_MAX_LINE_BYTES;
+      if (full ||
+          this.failed) {
+        record.event = this.failed ? 'capture-failed' : 'capture-truncated';
+        for (const key of Object.keys(record)) {
+          if (!base.includes(key)) delete record[key];
+        }
+        this.stopped = true;
+      }
+      validateTraceRecord(record);
+      const line = JSON.stringify(record) + '\n';
+      this.#append(line);
+      this.events++;
+      this.bytes += Buffer.byteLength(line);
+      if (this.stopped) this.close();
+    } catch {
+      // Diagnostics must never replace the operation's result or error.
+      this.failed = true;
+      if (this.#owned) this.close();
+    }
+  }
+
+  #append(line) {
+    if (this.#descriptor === undefined) {
+      this.#path = join(this.directory, `${process.pid}-${threadId}.jsonl`);
+      this.#descriptor = fs.openSync(this.#path, 'wx', 0o600);
+      this.#owned = true;
+      this.#identity = fs.fstatSync(this.#descriptor, { bigint: true });
+    }
+    this.#checkOwned(this.#written);
+    // A replacement after the check cannot redirect this write to another file.
+    fs.appendFileSync(this.#descriptor, line);
+    const written = this.#written + Buffer.byteLength(line);
+    this.#checkOwned(written);
+    this.#written = written;
+  }
+
+  #checkOwned(bytes) {
+    const open = fs.fstatSync(this.#descriptor, { bigint: true });
+    const named = fs.lstatSync(this.#path, { bigint: true });
+    const owned = [open, named].every((stat) =>
+      stat.isFile() && !stat.isSymbolicLink() && stat.nlink === 1n &&
+      stat.dev === this.#identity.dev && stat.ino === this.#identity.ino &&
+      stat.size === BigInt(bytes));
+    if (!owned) throw new Error('Pooling trace file ownership changed.');
+  }
+
+  close() {
+    if (this.#closed) return;
+    this.#closed = true;
+    this.stopped = true;
+    const descriptor = this.#descriptor;
+    this.#descriptor = undefined;
+    if (descriptor === undefined) return;
+    try {
+      fs.closeSync(descriptor);
+    } catch {
+      this.failed = true;
+    }
+  }
+}
+
+export const poolingTrace = new PoolingTrace(process.env.MCP_POOLING_TRACE_DIR);
+if (poolingTrace.directory) process.once('exit', () => poolingTrace.close());

package/bin/pooling-writer.mjs

@@ -1,32 +1,51 @@
 import { Worker, isMainThread, parentPort, workerData } from 'node:worker_threads';
 import { PoolingConfigStore, PoolingConfigError } from './pooling-config.mjs';
 import { PoolingExecution, POOLING_BUDGET_MS } from './pooling-execution.mjs';
+import { poolingTrace, traceErrorCode } from './pooling-trace.mjs';
 
 if (!isMainThread &&
     workerData?.kind === 'mcp-pooling-writer') {
+  poolingTrace.operation(undefined, workerData.traceContext)?.record('worker-ready');
   const store = new PoolingConfigStore(workerData.configPath);
-  parentPort.on('message', ({ id, method, request, deadline, buffer }) => {
+  parentPort.on('message', ({ id, method, request, deadline, buffer, traceContext }) => {
     if (method === 'close') {
+      store.close();
       parentPort.close();
       return;
     }
     const execution = new PoolingExecution(deadline, buffer);
+    execution.trace = poolingTrace.operation(deadline, traceContext);
+    execution.trace?.record('worker-enter', { method, state: Atomics.load(execution.state, 0) });
+    let cancelledBatchId;
     try {
       execution.check();
-      if (method !== 'apply' &&
-          method !== 'undo') {
+      if (!['apply', 'undo', 'stageApply', 'stageUndo', 'rejectStage', 'commitBatch'].includes(method)) {
         throw new PoolingConfigError(400, 'INVALID_REQUEST', 'Unknown pooling operation.');
       }
       const result = store[method](request, execution);
-      const completedLate = execution.complete();
+      if (result.cancelled) cancelledBatchId = result.batchId;
+      let completedLate;
+      try {
+        completedLate = execution.complete();
+      } catch (error) {
+        if (result.pending &&
+            result.accepted !== false) {
+          store.rejectStage(result, new PoolingExecution(
+            process.hrtime.bigint() + BigInt(POOLING_BUDGET_MS) * 1000000n));
+        }
+        throw error;
+      }
+      execution.trace?.record('worker-result', { state: Atomics.load(execution.state, 0) });
       parentPort.postMessage({ id, result, completedLate });
     } catch (error) {
-      execution.fail();
+      execution.trace?.record('worker-error', { code: traceErrorCode(error), state: Atomics.load(execution.state, 0) });
+      execution.fail(error.commitState);
       const known = error instanceof PoolingConfigError;
-      parentPort.postMessage({ id, error: {
+      parentPort.postMessage({ id, cancelledBatchId, error: {
         statusCode: known ? error.statusCode : 500,
         code: known ? error.code : 'WRITER_FAILED',
         message: known ? error.message : 'Pooling writer failed. Reread the config before retrying.',
+        commitState: error.commitState,
       } });
     }
   });
@@ -54,6 +73,22 @@ export class PoolingConfigWriter {
     return this.#send('undo', request, options);
   }
 
+  stageApply(request, options = {}) {
+    return this.#send('stageApply', request, options);
+  }
+
+  stageUndo(request, options = {}) {
+    return this.#send('stageUndo', request, options);
+  }
+
+  commitBatch(request, options = {}) {
+    return this.#send('commitBatch', request, options);
+  }
+
+  rejectStage(request) {
+    return this.#send('rejectStage', request, {});
+  }
+
   #send(method, request, options) {
     if (this.#closed) {
       return Promise.reject(new PoolingConfigError(503, 'WRITER_CLOSED', 'Pooling writer is shutting down.'));
@@ -63,6 +98,7 @@ export class PoolingConfigWriter {
     const deadline = options.deadline === undefined ? defaultDeadline
       : options.deadline < defaultDeadline ? options.deadline : defaultDeadline;
     const execution = new PoolingExecution(deadline);
+    execution.trace = options.trace ?? poolingTrace.operation(deadline);
     if (options.signal?.aborted) return Promise.reject(execution.cancel());
     try {
       execution.check();
@@ -72,12 +108,14 @@ export class PoolingConfigWriter {
     if (this.#pending.size >= 16) {
       return Promise.reject(new PoolingConfigError(503, 'WRITER_BUSY', 'Too many pending pooling changes.'));
     }
-    if (!this.#worker) this.#start();
+    execution.trace?.record('writer-send', { method, queued: this.#pending.size, cold: !this.#worker });
+    if (!this.#worker) this.#start(execution.trace);
     const id = ++this.#sequence;
     return new Promise((resolve, reject) => {
-      const pending = { resolve, reject, execution, options, settled: false };
+      const pending = { resolve, reject, execution, options, method, settled: false };
       const cancel = (expired) => {
         if (pending.settled) return;
+        execution.trace?.record('writer-expire', { expired, state: Atomics.load(execution.state, 0) });
         const error = execution.cancel(expired);
         if (!error) return;
         this.#settle(pending, error);
@@ -87,7 +125,8 @@ export class PoolingConfigWriter {
       try {
         options.signal?.addEventListener('abort', pending.abort, { once: true });
         pending.timer = setTimeout(() => cancel(true), execution.remainingMs());
-        this.#worker.postMessage({ id, method, request, deadline, buffer: execution.state.buffer });
+        this.#worker.postMessage({ id, method, request, deadline, buffer: execution.state.buffer,
+          traceContext: execution.trace?.context });
       } catch (error) {
         this.#pending.delete(id);
         this.#settle(pending, error);
@@ -95,17 +134,45 @@ export class PoolingConfigWriter {
     });
   }
 
-  #start() {
+  #start(trace) {
     this.#worker = new Worker(new URL(import.meta.url), {
-      workerData: { kind: 'mcp-pooling-writer', configPath: this.#configPath },
+      workerData: { kind: 'mcp-pooling-writer', configPath: this.#configPath, traceContext: trace?.context },
     });
-    this.#worker.on('message', ({ id, result, error, completedLate }) => {
+    this.#worker.on('message', async ({ id, result, error, completedLate, cancelledBatchId }) => {
       const pending = this.#pending.get(id);
       if (!pending) return;
+      pending.execution.trace?.record('writer-result', {
+        code: traceErrorCode(error), state: Atomics.load(pending.execution.state, 0),
+      });
       this.#pending.delete(id);
-      const failure = error
+      let failure = error
         ? new PoolingConfigError(error.statusCode, error.code, error.message)
         : completedLate ? pending.execution.committedLate() : undefined;
+      cancelledBatchId ??= result?.cancelled ? result.batchId : undefined;
+      if (!failure &&
+          cancelledBatchId &&
+          pending.options.signal?.aborted) {
+        failure = new PoolingConfigError(408, 'WRITER_CANCELLED',
+          'Pooling change was cancelled before config commit.');
+      }
+      if (failure) {
+        failure.commitState = error?.commitState ?? failure.commitState ??
+          (pending.method === 'commitBatch' ? 'not-committed' : undefined);
+        if (cancelledBatchId) failure.cancelledBatchId = cancelledBatchId;
+      }
+      if (!failure &&
+          result?.pending &&
+          result.accepted !== false &&
+          pending.options.signal?.aborted) {
+        try {
+          await this.rejectStage({ generation: result.generation });
+          this.#settle(pending, new PoolingConfigError(408, 'WRITER_CANCELLED',
+            'Pooling change was cancelled before config commit.'));
+        } catch (cleanupError) {
+          this.#settle(pending, cleanupError);
+        }
+        return;
+      }
       if (pending.settled ||
           completedLate) this.#lateSettlement(pending, failure, result);
       this.#settle(pending, failure, result);
@@ -147,7 +214,13 @@ export class PoolingConfigWriter {
   #lateSettlement(pending, error, result, commitStarted = false) {
     if (pending.options.onLateSettlement) {
       try {
-        pending.options.onLateSettlement({ error, committed: Boolean(result), commitStarted });
+        pending.options.onLateSettlement({
+          error, result,
+          committed: Boolean(result && !result.pending && !result.cancelled) ||
+            error?.commitState === 'committed',
+          cancelledBatchId: error?.cancelledBatchId ?? (result?.cancelled ? result.batchId : undefined),
+          commitStarted,
+        });
       } catch {
         process.emitWarning('Unable to reconcile a pooling operation without a normal result.');
       }

package/bin/prewarm.mjs

@@ -29,10 +29,46 @@ async function jsonRequest(port, path, options = {}) {
   if (!response.ok) {
     throw new Error(result.error || `Bridge on :${port} rejected the request (${response.status})`);
   }
-  return result;
+  return { status: response.status, body: result };
 }
 
-export function formatPrewarm(snapshot) {
+function validatePendingReceipt(receipt, name, port) {
+  const invalid = 'Bridge returned an invalid HTTP 202 receipt. Reread settings before retrying.';
+  const nonempty = (value) => typeof value === 'string' && value.length > 0;
+  const fieldsValid = receipt?.ok === true && receipt.pending === true &&
+    receipt.name === name && nonempty(receipt.batchId) &&
+    nonempty(receipt.undoId) && nonempty(receipt.revision);
+  if (!fieldsValid) throw new Error(invalid);
+
+  const snapshot = receipt.snapshot;
+  const snapshotValid = snapshot?.service === 'mcp-pacemaker' &&
+    snapshot.port === port && nonempty(snapshot.instanceId) &&
+    Number.isSafeInteger(snapshot.snapshotVersion) && snapshot.snapshotVersion > 0 &&
+    Array.isArray(snapshot.servers) && snapshot.servers.some((server) => server?.name === name) &&
+    snapshot.prewarm?.revision === receipt.revision &&
+    Number.isSafeInteger(snapshot.prewarm.maxWarm) && snapshot.prewarm.maxWarm > 0 &&
+    Number.isFinite(snapshot.prewarm.batchDelayMs) && snapshot.prewarm.batchDelayMs > 0 &&
+    Array.isArray(snapshot.prewarm.batches);
+  if (!snapshotValid) throw new Error(invalid);
+
+  const batch = snapshot.prewarm.batches.find((candidate) => candidate?.id === receipt.batchId);
+  const timingValid = batch?.status === 'pending' ? Number.isFinite(batch.applyAt)
+    : batch?.status === 'applying' && batch.applyAt === null;
+  const changesValid = Array.isArray(batch?.changes) && batch.changes.length > 0 &&
+    batch.changes.some((change) => change?.name === name) &&
+    batch.changes.every((change) => nonempty(change?.name) &&
+      (change.mode === 'pool'
+        ? change.minWarm === undefined ||
+          Number.isSafeInteger(change.minWarm) && change.minWarm >= 1 && change.minWarm <= snapshot.prewarm.maxWarm
+        : change.mode === 'isolated' && change.minWarm === undefined));
+  if (!timingValid ||
+      !changesValid ||
+      batch.revision !== receipt.revision) {
+    throw new Error(invalid);
+  }
+}
+
+export function formatPrewarm(snapshot, now = Date.now()) {
   const seconds = (ms) => ms == null ? '-' : `${(ms / 1000).toFixed(1)}s`;
   const rows = [
     ['SERVER', 'MODE', 'WARM/TARGET', 'STARTS', 'COLD P50', 'P95', 'SUGGESTED', 'SHARED CHILD'],
@@ -50,11 +86,30 @@ export function formatPrewarm(snapshot) {
     ]),
   ];
   const widths = rows[0].map((_, column) => Math.max(...rows.map((row) => row[column].length)));
+  const history = snapshot.prewarm?.batches ?? [];
+  const latestFinished = history.find((batch) => ['applied', 'failed', 'cancelled'].includes(batch.status));
+  const batches = history
+    .filter((batch) => ['pending', 'applying'].includes(batch.status) ||
+      batch === latestFinished && batch.status === 'failed')
+    .map((batch) => {
+      const changes = batch.changes.map((change) => {
+        const target = change.minWarm === undefined
+          ? 'pooling with configured target' : `${change.minWarm} warm slot(s)`;
+        return `${change.name}: ${change.mode === 'pool' ? target : 'pre-warming off'}`;
+      }).join(', ');
+      if (batch.status === 'failed') return `Batch failed (${changes}): ${batch.error || 'Reread settings before retrying.'}`;
+      if (batch.status === 'applying') return `Applying batch: ${changes}.`;
+      const secondsLeft = Math.max(0, Math.ceil((batch.applyAt - now) / 1000));
+      return `Pending batch (reload in ${secondsLeft}s): ${changes}. Active settings above have not changed.`;
+    });
   return [
     `Pre-warming on :${snapshot.port} (process counters since ${snapshot.startedAt || 'bridge start'})`,
     ...rows.map((row) => row.map((cell, column) => cell.padEnd(widths[column])).join('  ').trimEnd()),
     'Pre-warming is opt-in. Each warm slot holds one additional resident process.',
     'Shared mode is separately opt-in: compatible stateless tools sessions reuse one initialized child.',
+    ...(typeof snapshot.prewarm?.saveWarning === 'string'
+      ? [`File save notice: ${snapshot.prewarm.saveWarning}`] : []),
+    ...batches,
   ].join('\n');
 }
 
@@ -99,7 +154,7 @@ export async function runPrewarm(options, { configPath, ports, write = console.l
 
   const snapshots = [];
   for (const port of selectedPorts) {
-    const snapshot = await jsonRequest(port, '/api/status');
+    const { body: snapshot } = await jsonRequest(port, '/api/status');
     if (snapshot.service !== 'mcp-pacemaker') throw new Error(`:${port} is not a pacemaker bridge`);
     snapshots.push(snapshot);
   }
@@ -135,14 +190,40 @@ export async function runPrewarm(options, { configPath, ports, write = console.l
     }
   }
   const nonce = (await readFile(join(dirname(options.config || configPath), 'admin.nonce'), 'utf8')).trim();
-  const result = await jsonRequest(snapshot.port, `/admin/servers/${encodeURIComponent(name)}/pooling`, {
+  if (!options.json &&
+      typeof snapshot.prewarm.saveWarning === 'string') {
+    write(`File save notice: ${snapshot.prewarm.saveWarning}`);
+  }
+  const response = await jsonRequest(snapshot.port, `/admin/servers/${encodeURIComponent(name)}/pooling`, {
     method: 'POST',
-    headers: { 'content-type': 'application/json', 'x-mcp-nonce': nonce },
+    headers: { 'content-type': 'application/json', 'x-mcp-nonce': nonce, 'x-mcp-pooling-batch': '1' },
     body: JSON.stringify(body),
   });
-  if (result.ok !== true) throw new Error(result.error || 'Bridge did not confirm the pooling change');
+  const result = response.body;
+  if (response.status === 202) {
+    validatePendingReceipt(result, name, snapshot.port);
+  } else if (response.status !== 200 ||
+             result?.pending === true) {
+    throw new Error('Bridge returned an unexpected pooling response status. Reread settings before retrying.');
+  }
+  if (result?.ok !== true) throw new Error(result?.error || 'Bridge did not confirm the pooling change');
   if (options.json) {
     write(JSON.stringify(result));
+  } else if (result.pending) {
+    const batch = result.snapshot?.prewarm?.batches?.find((candidate) => candidate.id === result.batchId);
+    const scope = batch?.changes.map((change) => change.name).join(', ') || name;
+    const secondsLeft = batch?.applyAt == null ? null : Math.max(0, Math.ceil((batch.applyAt - Date.now()) / 1000));
+    const timing = secondsLeft === null ? '' : ` in ${secondsLeft}s`;
+    let action;
+    if (options.undo) action = 'previous batch configuration staged';
+    else if (body.mode === 'pool') action = `${body.minWarm} warm slot(s) staged`;
+    else action = 'pre-warming disable staged';
+    write(`${name}: ${action}. Pending reload${timing}; not active yet.`);
+    if (result.undoId) {
+      write(`Cancel while pending / undo after apply (entire batch: ${scope}): ${formatUndoCommand(snapshot.port, name, result.undoId, options.config)}`);
+    }
+  } else if (result.cancelled) {
+    write(`${name}: pending batch cancelled. Active settings were not changed.`);
   } else {
     write(`${name}: ${options.undo ? 'restored previous pooling settings' : body.mode === 'pool' ? `enabled ${body.minWarm} warm slot(s)` : 'disabled pre-warming'}`);
     if (result.undoId) {

package/bin/windows/PoolingSecurityHelper.build.json

@@ -1,7 +1,7 @@
 {
   "schemaVersion": 1,
   "binary": "PoolingSecurityHelper.exe",
-  "binarySha256": "effdc8deb06beab195523f714b8d1a396ec53f00b6b4a437e251a25d94234c9e",
+  "binarySha256": "db026df3593cf4b9467aa1a6a445f2dd4f3290198becb5bbdbfb484ce6b0ccc0",
   "inputs": {
     "targetFramework": ".NETFramework,Version=v4.6.2",
     "platform": "AnyCPU",
@@ -28,12 +28,15 @@
     "sourceSha256": {
       "AssemblyInfo.cs": "e81e107352fbcb82818d8265dfcdf392eac8d25df37e6d65ca7f02d1e63a6c9a",
       "PoolingSecurityReader.cs": "91620ba5e0b3c6fcc673319f59c96466115a6be74fd8b93808f08f07087b7038",
-      "PoolingSecurityHelper.cs": "aff0222cf28258f1004908b0ad6e471d00012d5ea7dd90af163d83eb743df6f0"
+      "PoolingSecurityHelper.cs": "1d14768fbf602368f20302bbe382e6d195e12db6008edb3aa95be0de88d75935",
+      "PoolingNativeFiles.cs": "1234fd12fb41910981385010a071358476b6a8a4c42827714f3f270f05f23c1d"
     },
-    "buildScriptSha256": "29dcb4641182bfe5552e9e913f90d4a37e99ddc7677b65b7dcb22cae16d98c60",
+    "buildScriptSha256": "8413c3ea3239a474379103cbf456f52a0a3bc75fcdb23b5f769474abe4a1eea0",
     "referenceSha256": {
       "mscorlib.dll": "7118fe658567606fa0538f7b5a2071e4606756c07e9062e1e5b24fa49e97d1f6",
-      "System.dll": "b76822f9c08aff597120e3167b3e0fbda836d6bc6f14bc4bc2eeffab5b2c6125"
+      "System.dll": "b76822f9c08aff597120e3167b3e0fbda836d6bc6f14bc4bc2eeffab5b2c6125",
+      "System.Core.dll": "774e965a6c25891a96d6d3b838ae10226ed9963a73b09e4be7c2ec275ffb5886",
+      "System.Web.Extensions.dll": "7a32bf3263aebed93c3a0847294aebdde15f7427541ed223a4cc4eb93c36d556"
     }
   }
 }