farming-code 2.2.8 → 2.2.12

package/frontend/terminal-replay.js

@@ -0,0 +1,372 @@
+(function attachTerminalReplay(global) {
+  const RUNTIME_EPOCH_PATTERN = /^farming-runtime-v1:(\d{20}):/;
+  const DEFAULT_MAX_QUEUED_TRANSITIONS = 512;
+  const DEFAULT_MAX_QUEUED_BYTES = 1024 * 1024;
+  const DEFAULT_RETRY_BASE_MS = 250;
+  const DEFAULT_RETRY_MAX_MS = 5000;
+  const DEFAULT_MAX_IDENTICAL_INVARIANT_FAILURES = 3;
+
+  function runtimeEpochGeneration(runtimeEpoch) {
+    const match = RUNTIME_EPOCH_PATTERN.exec(String(runtimeEpoch || ''));
+    if (!match) return null;
+    const generation = Number(match[1]);
+    return Number.isSafeInteger(generation) && generation > 0 ? generation : null;
+  }
+
+  function compareRuntimeEpochs(left, right) {
+    if (left === right) return 0;
+    const leftGeneration = runtimeEpochGeneration(left);
+    const rightGeneration = runtimeEpochGeneration(right);
+    if (leftGeneration === null || rightGeneration === null || leftGeneration === rightGeneration) {
+      return null;
+    }
+    return leftGeneration < rightGeneration ? -1 : 1;
+  }
+
+  function byteLength(value) {
+    const text = String(value || '');
+    if (typeof global.TextEncoder === 'function') {
+      return new global.TextEncoder().encode(text).byteLength;
+    }
+    return encodeURIComponent(text).replace(/%[0-9A-F]{2}/gi, 'x').length;
+  }
+
+  function createState(options = {}) {
+    return {
+      runtimeEpoch: '',
+      outputSeq: null,
+      stateRevision: null,
+      replayTargetEpoch: '',
+      replayTargetRevision: null,
+      recovering: false,
+      queuedTransitions: [],
+      queuedBytes: 0,
+      retiredRuntimeEpochs: new Set(),
+      failureCount: 0,
+      invariantFailureSignature: '',
+      invariantFailureCount: 0,
+      halted: false,
+      haltMessage: '',
+      maxQueuedTransitions: options.maxQueuedTransitions || DEFAULT_MAX_QUEUED_TRANSITIONS,
+      maxQueuedBytes: options.maxQueuedBytes || DEFAULT_MAX_QUEUED_BYTES,
+      retryBaseMs: options.retryBaseMs || DEFAULT_RETRY_BASE_MS,
+      retryMaxMs: options.retryMaxMs || DEFAULT_RETRY_MAX_MS,
+      maxIdenticalInvariantFailures:
+        options.maxIdenticalInvariantFailures || DEFAULT_MAX_IDENTICAL_INVARIANT_FAILURES,
+    };
+  }
+
+  function isTransitionValid(event) {
+    return Boolean(event && event.runtimeEpoch)
+      && Number.isFinite(event.outputSeq)
+      && Number.isFinite(event.stateRevision)
+      && (
+        event.kind !== 'resize'
+        || (Number.isFinite(event.cols) && Number.isFinite(event.rows))
+      );
+  }
+
+  function isCheckpointValid(checkpoint) {
+    return Boolean(checkpoint && checkpoint.runtimeEpoch)
+      && Number.isFinite(checkpoint.outputSeq)
+      && Number.isFinite(checkpoint.stateRevision)
+      && Number.isFinite(checkpoint.cols)
+      && Number.isFinite(checkpoint.rows)
+      && checkpoint.cols > 0
+      && checkpoint.rows > 0;
+  }
+
+  function noteReplayTarget(state, event) {
+    if (!event || !event.runtimeEpoch || !Number.isFinite(event.stateRevision)) return;
+    if (!state.replayTargetEpoch) {
+      state.replayTargetEpoch = event.runtimeEpoch;
+      state.replayTargetRevision = event.stateRevision;
+      return;
+    }
+    if (event.runtimeEpoch === state.replayTargetEpoch) {
+      state.replayTargetRevision = Math.max(state.replayTargetRevision || 0, event.stateRevision);
+      return;
+    }
+    const relation = compareRuntimeEpochs(event.runtimeEpoch, state.replayTargetEpoch);
+    if (relation === 1) {
+      state.replayTargetEpoch = event.runtimeEpoch;
+      state.replayTargetRevision = event.stateRevision;
+    }
+  }
+
+  function beginRecovery(state, event) {
+    state.recovering = true;
+    noteReplayTarget(state, event);
+  }
+
+  function isReplayTargetPending(state) {
+    if (!state.replayTargetEpoch || !Number.isFinite(state.replayTargetRevision)) return false;
+    if (!state.runtimeEpoch || !Number.isFinite(state.stateRevision)) return true;
+    if (state.runtimeEpoch === state.replayTargetEpoch) {
+      return state.stateRevision < state.replayTargetRevision;
+    }
+    return compareRuntimeEpochs(state.runtimeEpoch, state.replayTargetEpoch) !== 1;
+  }
+
+  function classifyTransition(state, event) {
+    if (!isTransitionValid(event)) {
+      beginRecovery(state, event);
+      return { action: 'recover', reason: 'invalid-transition' };
+    }
+    if (state.retiredRuntimeEpochs.has(event.runtimeEpoch)) {
+      return { action: 'drop', reason: 'retired-epoch' };
+    }
+    if (state.runtimeEpoch && event.runtimeEpoch !== state.runtimeEpoch) {
+      const relation = compareRuntimeEpochs(event.runtimeEpoch, state.runtimeEpoch);
+      if (relation === -1) return { action: 'drop', reason: 'older-epoch' };
+      beginRecovery(state, event);
+      return { action: 'recover', reason: 'epoch-change' };
+    }
+    if (!state.runtimeEpoch || !Number.isFinite(state.outputSeq) || !Number.isFinite(state.stateRevision)) {
+      beginRecovery(state, event);
+      return { action: 'recover', reason: 'missing-cursor' };
+    }
+    if (event.stateRevision <= state.stateRevision) {
+      return { action: 'drop', reason: 'duplicate' };
+    }
+
+    const outputAdvance = event.kind === 'output' ? 1 : 0;
+    if (
+      event.stateRevision !== state.stateRevision + 1
+      || event.outputSeq !== state.outputSeq + outputAdvance
+    ) {
+      beginRecovery(state, event);
+      return { action: 'recover', reason: 'sequence-gap' };
+    }
+    return { action: 'apply' };
+  }
+
+  function queueTransition(state, event) {
+    if (!isTransitionValid(event)) {
+      beginRecovery(state, event);
+      return { queued: false, overflow: false };
+    }
+    noteReplayTarget(state, event);
+    const bytes = byteLength(event.data);
+    if (
+      state.queuedTransitions.length >= state.maxQueuedTransitions
+      || state.queuedBytes + bytes > state.maxQueuedBytes
+    ) {
+      state.queuedTransitions = [];
+      state.queuedBytes = 0;
+      state.recovering = true;
+      return { queued: false, overflow: true };
+    }
+    state.queuedTransitions.push(event);
+    state.queuedBytes += bytes;
+    return { queued: true, overflow: false };
+  }
+
+  function takeQueuedTransition(state) {
+    const event = state.queuedTransitions.shift() || null;
+    if (event) state.queuedBytes = Math.max(0, state.queuedBytes - byteLength(event.data));
+    return event;
+  }
+
+  function clearQueuedTransitions(state) {
+    state.queuedTransitions = [];
+    state.queuedBytes = 0;
+  }
+
+  function checkpointInvariant(signature, message) {
+    return { action: 'reject', signature, message };
+  }
+
+  function queuedTransitionsCoverTarget(state, checkpoint) {
+    if (
+      checkpoint.runtimeEpoch !== state.replayTargetEpoch
+      || !Number.isFinite(state.replayTargetRevision)
+    ) return false;
+
+    let outputSeq = checkpoint.outputSeq;
+    let stateRevision = checkpoint.stateRevision;
+    for (const event of state.queuedTransitions) {
+      if (!isTransitionValid(event) || event.runtimeEpoch !== checkpoint.runtimeEpoch) return false;
+      if (event.stateRevision <= stateRevision) continue;
+      const outputAdvance = event.kind === 'output' ? 1 : 0;
+      if (
+        event.stateRevision !== stateRevision + 1
+        || event.outputSeq !== outputSeq + outputAdvance
+      ) return false;
+      outputSeq = event.outputSeq;
+      stateRevision = event.stateRevision;
+      if (stateRevision >= state.replayTargetRevision) return true;
+    }
+    return false;
+  }
+
+  function evaluateCheckpoint(state, checkpoint) {
+    if (!isCheckpointValid(checkpoint)) {
+      return checkpointInvariant('invalid-checkpoint', 'Terminal replay returned an invalid screen state');
+    }
+    if (state.runtimeEpoch && checkpoint.runtimeEpoch !== state.runtimeEpoch) {
+      const relation = compareRuntimeEpochs(checkpoint.runtimeEpoch, state.runtimeEpoch);
+      if (relation === -1 || state.retiredRuntimeEpochs.has(checkpoint.runtimeEpoch)) {
+        return checkpointInvariant(
+          `older-epoch:${checkpoint.runtimeEpoch}:${state.runtimeEpoch}`,
+          'Terminal replay returned an older runtime epoch',
+        );
+      }
+    } else if (
+      checkpoint.runtimeEpoch === state.runtimeEpoch
+      && Number.isFinite(state.stateRevision)
+      && checkpoint.stateRevision < state.stateRevision
+    ) {
+      return checkpointInvariant(
+        `older-revision:${checkpoint.runtimeEpoch}:${checkpoint.stateRevision}:${state.stateRevision}`,
+        'Terminal replay returned an older screen state',
+      );
+    }
+
+    if (state.replayTargetEpoch && Number.isFinite(state.replayTargetRevision)) {
+      if (checkpoint.runtimeEpoch === state.replayTargetEpoch) {
+        if (
+          checkpoint.stateRevision < state.replayTargetRevision
+          && !queuedTransitionsCoverTarget(state, checkpoint)
+        ) {
+          return checkpointInvariant(
+            `behind-target:${checkpoint.runtimeEpoch}:${checkpoint.stateRevision}:${state.replayTargetRevision}`,
+            'Terminal replay did not reach the latest observed screen state',
+          );
+        }
+      } else if (compareRuntimeEpochs(checkpoint.runtimeEpoch, state.replayTargetEpoch) !== 1) {
+        return checkpointInvariant(
+          `wrong-target-epoch:${checkpoint.runtimeEpoch}:${state.replayTargetEpoch}`,
+          'Terminal replay returned a different runtime epoch',
+        );
+      }
+    }
+
+    const current = checkpoint.runtimeEpoch === state.runtimeEpoch
+      && checkpoint.outputSeq === state.outputSeq
+      && checkpoint.stateRevision === state.stateRevision;
+    return { action: current ? 'current' : 'install' };
+  }
+
+  function removeCheckpointCoveredTransitions(state, checkpoint) {
+    state.queuedTransitions = state.queuedTransitions.filter((event) => {
+      if (!isTransitionValid(event)) return false;
+      if (state.retiredRuntimeEpochs.has(event.runtimeEpoch)) return false;
+      if (event.runtimeEpoch === checkpoint.runtimeEpoch) {
+        return event.stateRevision > checkpoint.stateRevision;
+      }
+      return compareRuntimeEpochs(event.runtimeEpoch, checkpoint.runtimeEpoch) !== -1;
+    });
+    state.queuedBytes = state.queuedTransitions.reduce(
+      (total, event) => total + byteLength(event.data),
+      0,
+    );
+  }
+
+  function clearFailures(state) {
+    state.failureCount = 0;
+    state.invariantFailureSignature = '';
+    state.invariantFailureCount = 0;
+    state.halted = false;
+    state.haltMessage = '';
+  }
+
+  function commitCheckpoint(state, checkpoint) {
+    if (state.runtimeEpoch && state.runtimeEpoch !== checkpoint.runtimeEpoch) {
+      state.retiredRuntimeEpochs.add(state.runtimeEpoch);
+      while (state.retiredRuntimeEpochs.size > 4) {
+        state.retiredRuntimeEpochs.delete(state.retiredRuntimeEpochs.values().next().value);
+      }
+    }
+    state.runtimeEpoch = checkpoint.runtimeEpoch;
+    state.outputSeq = checkpoint.outputSeq;
+    state.stateRevision = checkpoint.stateRevision;
+    removeCheckpointCoveredTransitions(state, checkpoint);
+    clearFailures(state);
+    state.recovering = isReplayTargetPending(state);
+    if (state.recovering && queuedTransitionsCoverTarget(state, checkpoint)) {
+      state.recovering = false;
+    }
+    if (!state.recovering) {
+      state.replayTargetEpoch = '';
+      state.replayTargetRevision = null;
+    }
+    return !state.recovering;
+  }
+
+  function commitTransition(state, event) {
+    state.runtimeEpoch = event.runtimeEpoch;
+    state.outputSeq = event.outputSeq;
+    state.stateRevision = event.stateRevision;
+    if (!isReplayTargetPending(state)) {
+      state.replayTargetEpoch = '';
+      state.replayTargetRevision = null;
+      state.recovering = false;
+    }
+  }
+
+  function retryDelay(state) {
+    const exponent = Math.max(0, state.failureCount - 1);
+    return Math.min(state.retryMaxMs, state.retryBaseMs * (2 ** exponent));
+  }
+
+  function recordTransportFailure(state) {
+    state.failureCount += 1;
+    state.recovering = true;
+    return { halted: false, delay: retryDelay(state), message: '' };
+  }
+
+  function recordInvariantFailure(state, signature, message) {
+    state.failureCount += 1;
+    state.recovering = true;
+    if (state.invariantFailureSignature === signature) {
+      state.invariantFailureCount += 1;
+    } else {
+      state.invariantFailureSignature = signature;
+      state.invariantFailureCount = 1;
+    }
+    if (state.invariantFailureCount >= state.maxIdenticalInvariantFailures) {
+      state.halted = true;
+      state.haltMessage = message || 'Terminal replay could not prove a current screen state';
+    }
+    return {
+      halted: state.halted,
+      delay: state.halted ? 0 : retryDelay(state),
+      message: state.haltMessage,
+    };
+  }
+
+  function resetRecovery(state, options = {}) {
+    clearQueuedTransitions(state);
+    state.replayTargetEpoch = '';
+    state.replayTargetRevision = null;
+    state.recovering = false;
+    clearFailures(state);
+    if (options.keepCursor === false) {
+      state.runtimeEpoch = '';
+      state.outputSeq = null;
+      state.stateRevision = null;
+      state.retiredRuntimeEpochs.clear();
+    }
+  }
+
+  const api = {
+    createState,
+    compareRuntimeEpochs,
+    beginRecovery,
+    isReplayTargetPending,
+    classifyTransition,
+    queueTransition,
+    takeQueuedTransition,
+    clearQueuedTransitions,
+    evaluateCheckpoint,
+    commitCheckpoint,
+    commitTransition,
+    recordTransportFailure,
+    recordInvariantFailure,
+    resetRecovery,
+  };
+
+  global.FarmingTerminalReplay = api;
+  if (typeof module === 'object' && module.exports) module.exports = api;
+})(typeof globalThis === 'object' ? globalThis : window);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "farming-code",
-  "version": "2.2.8",
+  "version": "2.2.12",
   "description": "Remote browser workspace for supervising AI coding agents",
   "main": "backend/server.js",
   "bin": {
@@ -14,9 +14,11 @@
     "config/*.example",
     "dist/",
     "frontend/*.js",
+    "frontend/farming-net/",
     "frontend/skins/",
     "frontend/themes/",
     "frontend/vendor/ghostty-web/",
+    "shared/",
     "scripts/sync-ghostty-vendor.js",
     "LICENSE",
     "README.md",
@@ -30,6 +32,7 @@
     "postinstall": "node scripts/sync-ghostty-vendor.js",
     "prepack": "FARMING_BASE_PATH=/farming npm run build",
     "start": "npm run build && node backend/server.js",
+    "start:net": "node backend/farming-net-server.js",
     "start:no-auth": "FARMING_DISABLE_AUTH=1 npm start",
     "dev:backend": "node backend/server.js",
     "dev:frontend": "vite",
@@ -50,6 +53,10 @@
     "docs:product:screenshots": "node scripts/capture-product-screenshots.js",
     "test": "node scripts/run-tests.js",
     "test:codex-app-server:real": "FARMING_REAL_CODEX_APP_SERVER_SMOKE=1 node scripts/smoke-codex-app-server.js",
+    "test:pre-release:codex-ui": "FARMING_REAL_CODEX_BIN=\"$(command -v codex)\" FARMING_CODEX_BIN=\"$PWD/tests/e2e/fixtures/real-codex-no-update\" FARMING_REAL_CODEX_RELEASE_CASE=1 FARMING_E2E_REAL_CODEX=1 FARMING_PLAYWRIGHT_INTERNAL=1 playwright test tests/e2e/internal/real-codex-release-case.spec.ts --project=chromium --workers=1 --retries=0 --trace=retain-on-failure",
+    "test:pre-release:terminal-input": "playwright test tests/e2e/terminal-input-performance.spec.ts --project=chromium --workers=1 --retries=0 --trace=retain-on-failure",
+    "test:performance:audit": "node tests/performance/agent-usage-hotpath.js && FARMING_PLAYWRIGHT_INTERNAL=1 playwright test tests/e2e/internal/performance-bottlenecks.spec.ts --project=chromium --workers=1 --retries=0 --trace=retain-on-failure",
+    "test:performance:scale": "FARMING_PLAYWRIGHT_INTERNAL=1 playwright test tests/e2e/internal/performance-scaling.spec.ts --project=chromium --workers=1 --retries=0 --trace=retain-on-failure",
     "test:update:platforms": "node scripts/test-update-platforms.js",
     "test:e2e": "npm run test:e2e:playwright",
     "test:e2e:playwright": "playwright test",
@@ -89,8 +96,8 @@
     "node": ">=22"
   },
   "dependencies": {
-    "@agentclientprotocol/claude-agent-acp": "0.58.1",
-    "@agentclientprotocol/codex-acp": "1.1.2",
+    "@agentclientprotocol/claude-agent-acp": "0.59.0",
+    "@agentclientprotocol/codex-acp": "1.1.4",
     "@agentclientprotocol/sdk": "1.2.1",
     "@xterm/addon-clipboard": "^0.2.0",
     "@xterm/addon-fit": "^0.11.0",

package/shared/browser-protocol.d.ts

@@ -0,0 +1,5 @@
+export const PROTOCOL_VERSION: number
+export const MIN_PROTOCOL_VERSION: number
+export function protocolCompatible(version: number): boolean
+export function validateClientMessage(value: unknown): { ok: true; value: Record<string, unknown> } | { ok: false; error: string }
+export function validateServerMessage(value: unknown): { ok: true; value: Record<string, unknown> } | { ok: false; error: string }

package/shared/browser-protocol.js

@@ -0,0 +1,130 @@
+const PROTOCOL_VERSION = 2;
+const MIN_PROTOCOL_VERSION = 2;
+
+const CLIENT_MESSAGE_TYPES = new Set([
+  'protocol-hello',
+  'start-agent',
+  'input',
+  'composer-input',
+  'app-server-request-response',
+  'acp-permission-response',
+  'interrupt-agent',
+  'focus-agent',
+  'resize-agent',
+  'clear-terminal',
+  'watch-workspace-files',
+  'unwatch-workspace-files',
+  'kill-agent',
+  'restart-main-agent',
+]);
+
+const SERVER_MESSAGE_TYPES = new Set([
+  'protocol-hello',
+  'protocol-error',
+  'command-ack',
+  'state',
+  'error',
+  'agent-started',
+  'session-output',
+  'session-preview',
+  'system-stats',
+  'agent-activity',
+  'agent-update',
+  'agent-read',
+  'workspace-file-watch',
+  'workspace-file-event',
+]);
+
+function objectMessage(value) {
+  return Boolean(value && typeof value === 'object' && !Array.isArray(value));
+}
+
+function stringField(value, name, optional = false) {
+  return optional && value[name] === undefined ? true : typeof value[name] === 'string';
+}
+
+function finiteField(value, name) {
+  return typeof value[name] === 'number' && Number.isFinite(value[name]);
+}
+
+const AGENT_UPDATE_PATCH_VALIDATORS = {
+  terminalInputReceived: value => typeof value === 'boolean',
+  terminalBusy: value => value === null || typeof value === 'boolean',
+  shellCwd: value => typeof value === 'string',
+  shellLastExitCode: value => value === null || Number.isFinite(value),
+  shellLastEvent: value => typeof value === 'string',
+  shellCommand: value => typeof value === 'string',
+  shellLastCommand: value => typeof value === 'string',
+  shellCommandStartedAt: value => value === null || Number.isFinite(value),
+  shellLastCommandStartedAt: value => value === null || Number.isFinite(value),
+  shellLastCommandFinishedAt: value => value === null || Number.isFinite(value),
+  shellLastCommandDurationMs: value => value === null || Number.isFinite(value),
+  terminalStatus: value => value === null || objectMessage(value),
+  runtimeObservation: objectMessage,
+};
+
+function sanitizeAgentUpdatePatch(value) {
+  if (!objectMessage(value)) return null;
+  const entries = Object.entries(value);
+  if (entries.length === 0 || entries.some(([name, field]) => (
+    !AGENT_UPDATE_PATCH_VALIDATORS[name] || !AGENT_UPDATE_PATCH_VALIDATORS[name](field)
+  ))) return null;
+  return Object.fromEntries(entries);
+}
+
+function validateClientMessage(value) {
+  if (!objectMessage(value) || typeof value.type !== 'string') return { ok: false, error: 'message must be an object with a type' };
+  if (!CLIENT_MESSAGE_TYPES.has(value.type)) return { ok: false, error: `unsupported client message: ${value.type}` };
+  let valid = true;
+  switch (value.type) {
+    case 'protocol-hello': valid = Number.isInteger(value.protocolVersion); break;
+    case 'start-agent': valid = stringField(value, 'command'); break;
+    case 'input': valid = stringField(value, 'agentId', true) && (typeof value.input === 'string' || Array.isArray(value.inputParts)); break;
+    case 'composer-input': valid = stringField(value, 'message') && stringField(value, 'agentId', true); break;
+    case 'app-server-request-response':
+    case 'acp-permission-response': valid = stringField(value, 'agentId') && stringField(value, 'requestId'); break;
+    case 'focus-agent': valid = value.agentId === null || stringField(value, 'agentId'); break;
+    case 'resize-agent': valid = stringField(value, 'agentId') && finiteField(value, 'cols') && finiteField(value, 'rows'); break;
+    case 'unwatch-workspace-files': valid = stringField(value, 'agentId', true); break;
+    case 'restart-main-agent': valid = stringField(value, 'command'); break;
+    default: valid = stringField(value, 'agentId'); break;
+  }
+  return valid ? { ok: true, value } : { ok: false, error: `invalid ${value.type} message` };
+}
+
+function validateServerMessage(value) {
+  if (!objectMessage(value) || typeof value.type !== 'string') return { ok: false, error: 'message must be an object with a type' };
+  if (!SERVER_MESSAGE_TYPES.has(value.type)) return { ok: false, error: `unsupported server message: ${value.type}` };
+  let valid = true;
+  switch (value.type) {
+    case 'protocol-hello': valid = Number.isInteger(value.protocolVersion) && Number.isInteger(value.minProtocolVersion); break;
+    case 'protocol-error':
+    case 'error': valid = stringField(value, 'message'); break;
+    case 'command-ack': valid = stringField(value, 'requestId') && stringField(value, 'command'); break;
+    case 'state': valid = objectMessage(value.state) && Array.isArray(value.state.agents); break;
+    case 'agent-started': valid = stringField(value, 'agentId'); break;
+    case 'session-output': valid = objectMessage(value.stream) && stringField(value.stream, 'agentId'); break;
+    case 'session-preview': valid = objectMessage(value.preview) && stringField(value.preview, 'agentId'); break;
+    case 'system-stats': valid = objectMessage(value.stats); break;
+    case 'agent-activity': valid = objectMessage(value.activity) && stringField(value.activity, 'agentId'); break;
+    case 'agent-update': valid = objectMessage(value.update) && stringField(value.update, 'agentId') && Boolean(sanitizeAgentUpdatePatch(value.update.patch)); break;
+    case 'agent-read': valid = objectMessage(value.read) && stringField(value.read, 'agentId'); break;
+    case 'workspace-file-watch': valid = stringField(value, 'agentId') && typeof value.watching === 'boolean'; break;
+    case 'workspace-file-event': valid = objectMessage(value.event) && stringField(value.event, 'agentId'); break;
+    default: break;
+  }
+  return valid ? { ok: true, value } : { ok: false, error: `invalid ${value.type} message` };
+}
+
+function protocolCompatible(version) {
+  return Number.isInteger(version) && version >= MIN_PROTOCOL_VERSION && version <= PROTOCOL_VERSION;
+}
+
+module.exports = {
+  MIN_PROTOCOL_VERSION,
+  PROTOCOL_VERSION,
+  protocolCompatible,
+  sanitizeAgentUpdatePatch,
+  validateClientMessage,
+  validateServerMessage,
+};