@getmarrow/mcp 3.9.80 → 3.9.81

package/README.md

@@ -116,7 +116,11 @@ npx -y --package=@getmarrow/mcp@latest marrow-mcp ping
 
 Detection and notification are automatic. After explicit installer activation, the local controller may restore only Marrow-managed hooks/configuration. Package upgrades, owner policy, credentials, and unrelated configuration remain explicit and subject to the operator's normal change policy.
 
-## What's New in v3.9.80
+## What's New in v3.9.81
+
+v3.9.81 adds bounded structured failure evidence to the authenticated eleven-tool control-path canary. Failed runs identify the observed stage, tool, error class, timing, and completed checks without retaining credentials, customer payloads, or arbitrary error text. Protocol and write failures observed after the final response or during shutdown now fail closed; the canary's own bounded cleanup remains compatible with a successful run. The eleven live-tool requirements, client deadlines, package identity checks, and retry limits are unchanged.
+
+### Previous release: v3.9.80
 
 v3.9.80 is a reliability patch for direct `marrow_think` and `marrow_commit` calls. Each invocation now carries one stable bounded idempotency key. Only the backend's documented pending-persistence states are reconciled, using the byte-identical request and key after a fixed one-second delay for at most three total attempts. A 202 response is never reported as successful completion; unknown, malformed, correlation-drifted, or exhausted pending responses fail closed with a structured error. Explicit caller-supplied idempotency keys remain unchanged, and durable `observed_unverified` outcomes retain their terminal, non-authorizing semantics.
 

package/dist/hook-contract.d.ts

@@ -1,8 +1,8 @@
 import { resolveMarrowEnv, type ResolvedMarrowEnv } from './env';
-export declare const MCP_ADAPTER_VERSION = "3.9.80";
+export declare const MCP_ADAPTER_VERSION = "3.9.81";
 export declare const NATIVE_HOOK_MATCHER = "Bash|Edit|Write|MultiEdit|mcp__(?!marrow__marrow_).*";
 export declare const GROK_NATIVE_HOOK_MATCHER = "run_terminal_command|search_replace|write|spawn_subagent|use_tool|workflow|image_gen|image_edit|image_to_video|reference_to_video";
-export declare const MCP_PACKAGE_SPEC = "@getmarrow/mcp@3.9.80";
+export declare const MCP_PACKAGE_SPEC = "@getmarrow/mcp@3.9.81";
 export declare const CONTEXT_HOOK_COMMAND: string;
 export declare const PRE_ACTION_HOOK_COMMAND: string;
 export declare const ACTION_RESULT_HOOK_COMMAND: string;

package/dist/hook-contract.js

@@ -20,7 +20,7 @@ const node_fs_1 = require("node:fs");
 const node_os_1 = require("node:os");
 const node_path_1 = require("node:path");
 const env_1 = require("./env");
-exports.MCP_ADAPTER_VERSION = '3.9.80';
+exports.MCP_ADAPTER_VERSION = '3.9.81';
 exports.NATIVE_HOOK_MATCHER = 'Bash|Edit|Write|MultiEdit|mcp__(?!marrow__marrow_).*';
 exports.GROK_NATIVE_HOOK_MATCHER = 'run_terminal_command|search_replace|write|spawn_subagent|use_tool|workflow|image_gen|image_edit|image_to_video|reference_to_video';
 exports.MCP_PACKAGE_SPEC = `@getmarrow/mcp@${exports.MCP_ADAPTER_VERSION}`;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@getmarrow/mcp",
-  "version": "3.9.80",
+  "version": "3.9.81",
   "mcpName": "io.github.getmarrow/marrow",
   "description": "Runtime control, proof, and fleet intelligence for MCP-compatible AI agents.",
   "bin": {

package/scripts/control-path-canary.cjs

@@ -3,18 +3,26 @@ const { spawn } = require('node:child_process');
 const { randomUUID } = require('node:crypto');
 const { performance } = require('node:perf_hooks');
 const { resolve } = require('node:path');
-const { version: packageVersion } = require('../package.json');
-const { MARROW_AUTO_RESPONSE_BUDGET_MAX_MS } = require('../dist/index.js');
+let packageVersion;
+let MARROW_AUTO_RESPONSE_BUDGET_MAX_MS;
+let configurationFailed = false;
+try {
+  ({ version: packageVersion } = require('../package.json'));
+  ({ MARROW_AUTO_RESPONSE_BUDGET_MAX_MS } = require('../dist/index.js'));
+} catch {
+  // A missing/broken build must still reach the CLI's bounded failure handler.
+  configurationFailed = true;
+}
 
 const CANARY_TOOL_TIMEOUT_MARGIN_MS = 2_000;
 const CANARY_TOOL_TIMEOUT_MAX_MS = 10_000;
 const CANARY_DEFAULT_TOOL_TIMEOUT_MS = Math.min(
   CANARY_TOOL_TIMEOUT_MAX_MS,
-  MARROW_AUTO_RESPONSE_BUDGET_MAX_MS + CANARY_TOOL_TIMEOUT_MARGIN_MS,
+  (MARROW_AUTO_RESPONSE_BUDGET_MAX_MS || 8_000) + CANARY_TOOL_TIMEOUT_MARGIN_MS,
 );
 
 if (CANARY_DEFAULT_TOOL_TIMEOUT_MS < MARROW_AUTO_RESPONSE_BUDGET_MAX_MS + CANARY_TOOL_TIMEOUT_MARGIN_MS) {
-  throw new Error('MCP canary timeout ceiling cannot contain the bounded marrow_auto budget');
+  configurationFailed = true;
 }
 
 function canaryCases(operationId) {
@@ -49,6 +57,68 @@ const HOT_PATH_TOOLS = new Set([
   'marrow_auto',
 ]);
 const OUTPUT_LIMIT_BYTES = 256 * 1024;
+const TOOL_NAMES = new Set(canaryCases('').map(([name]) => name));
+const errorEvidence = new WeakMap();
+const failureRecords = new WeakMap();
+
+function canaryError(errorClass, message = errorClass, httpStatus) {
+  const error = new Error(message);
+  errorEvidence.set(error, { error_class: errorClass, http_status: httpStatus });
+  return error;
+}
+
+function upstreamError(payload, fallback, message) {
+  const statuses = [payload?.http_status, payload?.status, payload?.status_code,
+    payload?.error?.http_status, payload?.error?.status, payload?.error?.status_code];
+  const status = statuses.find((value) => Number.isInteger(value) && value >= 100 && value <= 599);
+  const code = payload?.error?.code ?? payload?.error_code ?? payload?.code;
+  let errorClass = fallback;
+  if (status === 401 || ['UNAUTHORIZED', 'AUTH_REQUIRED', 'AUTHENTICATION_REQUIRED', 'INVALID_API_KEY', 'API_KEY_REQUIRED', 'unauthorized', 'invalid_api_key', 'authentication_required'].includes(code)) {
+    errorClass = 'authentication';
+  } else if (status === 403 || ['FORBIDDEN', 'PERMISSION_DENIED', 'INSUFFICIENT_PERMISSIONS', 'PLAN_REQUIRED', 'UPGRADE_REQUIRED', 'forbidden', 'permission_denied', 'plan_required'].includes(code)) {
+    errorClass = 'authorization';
+  } else if (status === 503 || code === 'HTTP_503' || code === 'http_503') {
+    errorClass = 'unavailable503';
+  }
+  return canaryError(errorClass, message, status);
+}
+
+function safeVersion(value) {
+  return typeof value === 'string' && value.length <= 64
+    && /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)$/.test(value) ? value : null;
+}
+
+function safeMs(value) {
+  return Number.isFinite(value) ? Math.max(0, Math.min(60_000, Math.round(value))) : 0;
+}
+
+function failureRecord(error, context = {}) {
+  const evidence = errorEvidence.get(error) || { error_class: 'internal' };
+  const results = (context.results || []).slice(0, 11).map((row) => Object.freeze({
+    tool: row.tool, ok: true, live: true, latency_ms: safeMs(row.latency_ms),
+  }));
+  return Object.freeze({
+    schema_version: 1,
+    ok: false,
+    stage: context.stage || 'setup',
+    tool: TOOL_NAMES.has(context.tool) ? context.tool : null,
+    error_class: evidence.error_class,
+    package_version: safeVersion(context.version),
+    expected_version: safeVersion(context.expectedVersion),
+    attempt: Math.max(0, Math.min(3, context.attempt || 0)),
+    latency_ms: safeMs(performance.now() - (context.stageStarted ?? performance.now())),
+    total_latency_ms: safeMs(performance.now() - (context.started ?? performance.now())),
+    process_count: context.processCount === 1 ? 1 : 0,
+    initialization_ms: context.initializationMs == null ? null : safeMs(context.initializationMs),
+    tools_checked: results.length,
+    results: Object.freeze(results),
+    ...(evidence.http_status === undefined ? {} : { http_status: evidence.http_status }),
+  });
+}
+
+function serializeFailure(error) {
+  return JSON.stringify(failureRecords.get(error) || failureRecord(error));
+}
 
 function boundedMs(name, fallback, minimum = 100, maximum = 10_000, env = process.env) {
   const parsed = Number(env[name] || fallback);
@@ -73,26 +143,25 @@ function latencyGroup(rows) {
 }
 
 function toolPayload(message, name) {
-  if (!message) throw new Error(`${name} returned no MCP tool response`);
-  if (message.error) throw new Error(`${name} returned JSON-RPC error ${message.error.code}`);
+  if (!message) throw canaryError('contract', 'Missing MCP tool response');
+  if (message.error) throw upstreamError(message, 'protocol', 'MCP JSON-RPC error');
   const result = message.result || {};
   const text = result.content?.[0]?.text;
-  if (typeof text !== 'string' || !text.trim()) throw new Error(`${name} returned no MCP tool payload`);
+  if (typeof text !== 'string' || !text.trim()) throw canaryError('contract', 'Missing MCP tool payload');
   let payload;
-  try { payload = JSON.parse(text); } catch { throw new Error(`${name} returned invalid tool JSON`); }
+  try { payload = JSON.parse(text); } catch { throw canaryError('contract', 'Invalid tool JSON'); }
   if (!payload || typeof payload !== 'object' || Array.isArray(payload) || Object.keys(payload).length === 0) {
-    throw new Error(`${name} returned an empty or invalid tool payload`);
+    throw canaryError('contract', 'Empty or invalid tool payload');
   }
   if (result.isError || payload.ok === false || payload.available === false) {
-    const code = payload.error?.code || payload.error_code || 'tool_unavailable';
-    throw new Error(`${name} unavailable (${code})`);
+    throw upstreamError(payload, 'tool_unavailable', 'MCP tool unavailable');
   }
   return payload;
 }
 
 function validatePayload(name, payload) {
   const requireField = (valid, field) => {
-    if (!valid) throw new Error(`${name} returned an invalid ${field} contract`);
+    if (!valid) throw canaryError('contract', `${name} returned an invalid ${field} contract`);
   };
   if (name === 'marrow_status' || name === 'marrow_runtime_status') {
     requireField(
@@ -160,27 +229,34 @@ class PersistentMcpClient {
 
   start() {
     if (this.child) return;
-    this.child = this.spawnProcess(this.command, this.args, {
-      env: this.env,
-      stdio: ['pipe', 'pipe', 'pipe'],
-    });
+    try {
+      this.child = this.spawnProcess(this.command, this.args, {
+        env: this.env,
+        stdio: ['pipe', 'pipe', 'pipe'],
+      });
+    } catch { throw canaryError('process_spawn', 'MCP child spawn failed'); }
     this.child.stdout.setEncoding('utf8');
     this.child.stdout.on('data', (chunk) => this.onStdout(chunk));
     this.child.stderr.on('data', (chunk) => {
       this.stderrBytes += Buffer.byteLength(chunk);
-      if (this.stderrBytes > this.maxOutputBytes) this.abort(new Error('MCP child exceeded stderr limit'));
+      if (this.stderrBytes > this.maxOutputBytes) this.abort(canaryError('output_limit', 'MCP child exceeded stderr limit'));
     });
-    this.child.once('error', (error) => this.abort(new Error(`MCP child failed: ${error.code || 'process_error'}`)));
+    this.child.stdin.on?.('error', () => this.abort(canaryError('process_write', 'MCP child write failed')));
+    this.child.once('error', () => this.abort(canaryError('process_spawn', 'MCP child spawn failed')));
     this.child.once('exit', (code, signal) => {
       this.closed = true;
-      if (this.pending.size > 0) this.rejectAll(new Error(`MCP child exited ${code ?? signal ?? 'unknown'}`));
+      const expectedExit = (code === 0 && !signal)
+        || (this.cleanupKillRequested && code === null && signal === 'SIGKILL');
+      if (this.stopping && expectedExit && this.pending.size === 0 && !this.fatalError) return;
+      this.fatalError ||= canaryError('process_exit', 'MCP child exited');
+      this.rejectAll(this.fatalError);
     });
   }
 
   onStdout(chunk) {
     this.stdoutBuffer += chunk;
     if (Buffer.byteLength(this.stdoutBuffer) > this.maxOutputBytes) {
-      this.abort(new Error('MCP child exceeded stdout limit'));
+      this.abort(canaryError('output_limit', 'MCP child exceeded stdout limit'));
       return;
     }
     for (;;) {
@@ -191,13 +267,19 @@ class PersistentMcpClient {
       if (!line) continue;
       let message;
       try { message = JSON.parse(line); } catch {
-        this.abort(new Error('MCP child emitted malformed JSON'));
+        this.abort(canaryError('protocol', 'MCP child emitted malformed JSON'));
+        return;
+      }
+      if (!message || typeof message !== 'object' || Array.isArray(message) || message.jsonrpc !== '2.0'
+        || (message.id !== undefined && (!Number.isSafeInteger(message.id)
+          || (Object.hasOwn(message, 'result') === Object.hasOwn(message, 'error'))))) {
+        this.abort(canaryError('protocol', 'MCP child emitted malformed JSON-RPC'));
         return;
       }
       if (!Number.isSafeInteger(message.id)) continue;
       const pending = this.pending.get(message.id);
       if (!pending) {
-        this.abort(new Error(`MCP child returned unexpected response id ${message.id}`));
+        this.abort(canaryError('protocol', 'MCP child returned unexpected response id'));
         return;
       }
       clearTimeout(pending.timer);
@@ -207,25 +289,30 @@ class PersistentMcpClient {
   }
 
   request(method, params = {}, timeoutMs = this.timeoutMs) {
+    if (this.fatalError) return Promise.reject(this.fatalError);
     if (!this.child || this.closed || !this.child.stdin.writable) {
-      return Promise.reject(new Error('MCP child is not writable'));
+      return Promise.reject(canaryError('process_write', 'MCP child is not writable'));
     }
     const id = this.nextId++;
     return new Promise((resolveRequest, rejectRequest) => {
       const timer = setTimeout(() => {
         this.pending.delete(id);
-        const error = new Error(`${method} timed out`);
+        const error = canaryError('request_timeout', `${method} timed out`);
         rejectRequest(error);
         this.abort(error);
       }, timeoutMs);
       this.pending.set(id, { resolve: resolveRequest, reject: rejectRequest, timer });
-      this.child.stdin.write(`${JSON.stringify({ jsonrpc: '2.0', id, method, params })}\n`, (error) => {
+      const onWrite = (error) => {
         if (!error) return;
         clearTimeout(timer);
         this.pending.delete(id);
-        rejectRequest(new Error(`${method} write failed`));
-        this.abort(error);
-      });
+        const failure = canaryError('process_write', `${method} write failed`);
+        rejectRequest(failure);
+        this.abort(failure);
+      };
+      try {
+        this.child.stdin.write(`${JSON.stringify({ jsonrpc: '2.0', id, method, params })}\n`, onWrite);
+      } catch (error) { onWrite(error); }
     });
   }
 
@@ -238,16 +325,28 @@ class PersistentMcpClient {
   }
 
   abort(error) {
-    this.rejectAll(error instanceof Error ? error : new Error('MCP child aborted'));
-    if (this.child && !this.closed) this.child.kill('SIGKILL');
+    this.fatalError ||= error instanceof Error ? error : canaryError('internal');
+    this.rejectAll(this.fatalError);
+    if (this.child && !this.closed) {
+      try { this.child.kill('SIGKILL'); } catch { /* Preserve the original failure. */ }
+    }
   }
 
   async stop() {
-    if (!this.child || this.closed) return;
+    if (!this.child || this.closed) {
+      if (this.fatalError) throw this.fatalError;
+      return;
+    }
+    this.stopping = true;
     this.child.stdin.end();
     await new Promise((resolveExit) => {
       const timer = setTimeout(() => {
-        if (!this.closed) this.child.kill('SIGKILL');
+        if (!this.closed) {
+          // The bounded cleanup deadline intentionally ends an otherwise healthy
+          // child. This signal is ours; actual protocol/write errors remain fatal.
+          this.cleanupKillRequested = true;
+          try { this.child.kill('SIGKILL'); } catch { this.cleanupKillRequested = false; }
+        }
         resolveExit();
       }, 500);
       this.child.once('exit', () => {
@@ -255,12 +354,28 @@ class PersistentMcpClient {
         resolveExit();
       });
     });
+    if (this.fatalError) throw this.fatalError;
   }
 }
 
 async function runCanary(env = process.env, options = {}) {
+  const started = performance.now();
+  const context = { started, stageStarted: started, stage: 'setup', results: [],
+    expectedVersion: env.MARROW_EXPECTED_MCP_VERSION || packageVersion };
+  try {
+    return await executeCanary(env, options, context);
+  } catch (caught) {
+    const error = errorEvidence.has(caught) ? caught : canaryError('internal');
+    error.failure = failureRecord(error, context);
+    failureRecords.set(error, error.failure);
+    throw error;
+  }
+}
+
+async function executeCanary(env, options, context) {
+  if (configurationFailed) throw canaryError('configuration', 'MCP canary build configuration failed');
   const key = env.MARROW_API_KEY || '';
-  if (!key) throw new Error('MARROW_API_KEY is required for the authenticated MCP control-path canary');
+  if (!key) throw canaryError('authentication', 'MARROW_API_KEY is required for the authenticated MCP control-path canary');
   const toolTimeoutMs = boundedMs(
     'MARROW_MCP_CANARY_TOOL_TIMEOUT_MS',
     CANARY_DEFAULT_TOOL_TIMEOUT_MS,
@@ -291,30 +406,47 @@ async function runCanary(env = process.env, options = {}) {
     env: childEnv,
     spawnProcess: options.spawnProcess,
   });
-  const totalTimer = setTimeout(() => client.abort(new Error('MCP canary total timeout')), totalTimeoutMs);
+  const totalTimer = setTimeout(() => client.abort(canaryError('total_timeout', 'MCP canary total timeout')), totalTimeoutMs);
   const processStarted = performance.now();
   const cases = canaryCases(`canary_${randomUUID()}`);
-  client.start();
+  const stage = (value, tool = null, attempt = 0) => {
+    Object.assign(context, { stage: value, tool, attempt, stageStarted: performance.now() });
+  };
+  let failed = false;
   try {
+    stage('spawn');
+    client.start();
+    context.processCount = 1;
+    stage('initialize', null, 1);
     const initialized = await client.request('initialize', {}, toolTimeoutMs + 3_000);
-    if (initialized.error) throw new Error(`MCP initialize failed ${initialized.error.code}`);
+    if (client.fatalError) throw client.fatalError;
+    if (initialized.error) throw upstreamError(initialized, 'protocol', 'MCP initialize failed');
     const version = initialized.result?.serverInfo?.version;
-    if (!version) throw new Error('MCP initialize produced no version');
-    if (version !== expectedVersion) throw new Error(`MCP canary loaded ${version} instead of expected ${expectedVersion}`);
+    context.version = version;
+    if (typeof version !== 'string' || !version) throw canaryError('contract', 'MCP initialize produced no version');
+    if (version !== expectedVersion) throw canaryError('package_mismatch', 'MCP canary package version mismatch');
+    stage('tools_list', null, 1);
     const listed = await client.request('tools/list', {});
-    if (listed.error) throw new Error(`MCP tools/list failed ${listed.error.code}`);
-    const names = new Set((listed.result?.tools || []).map((tool) => tool.name));
+    if (client.fatalError) throw client.fatalError;
+    if (listed.error) throw upstreamError(listed, 'protocol', 'MCP tools/list failed');
+    if (!Array.isArray(listed.result?.tools)) throw canaryError('contract', 'MCP tools/list missing tools');
+    const names = new Set(listed.result.tools.map((tool) => tool?.name));
     for (const [name] of cases) {
-      if (!names.has(name)) throw new Error(`${name} is missing from the full MCP contract`);
+      if (!names.has(name)) throw canaryError('contract', `${name} is missing from the full MCP contract`);
     }
     const initializationMs = Math.round(performance.now() - processStarted);
-    const results = [];
+    context.initializationMs = initializationMs;
+    const results = context.results;
     for (const [name, args] of cases) {
       const callStarted = performance.now();
       let called;
       let payload;
       for (let attempt = 0; attempt < 3; attempt += 1) {
+        if (client.fatalError) throw client.fatalError;
+        stage('tool_call', name, attempt + 1);
         called = await client.request('tools/call', { name, arguments: args });
+        if (client.fatalError) throw client.fatalError;
+        stage('tool_validate', name, attempt + 1);
         payload = toolPayload(called, name);
         if (name !== 'marrow_auto' || payload.live_delivery?.committed === true || payload.resumable !== true) break;
         if (attempt < 2) {
@@ -326,11 +458,12 @@ async function runCanary(env = process.env, options = {}) {
       const latencyMs = Math.round(performance.now() - callStarted);
       validatePayload(name, payload);
       const live = payload.stale !== true && payload.source !== 'last_known' && payload.available !== false;
-      if (!live) throw new Error(`${name} returned cached or unavailable guidance`);
+      if (!live) throw canaryError('contract', `${name} returned cached or unavailable guidance`);
       results.push({ tool: name, ok: true, live: true, latency_ms: latencyMs });
     }
     const hotPath = results.filter((row) => HOT_PATH_TOOLS.has(row.tool));
     const reports = results.filter((row) => !HOT_PATH_TOOLS.has(row.tool));
+    stage('shutdown');
     return {
       ok: true,
       package_version: version,
@@ -344,9 +477,14 @@ async function runCanary(env = process.env, options = {}) {
       },
       results,
     };
+  } catch (error) {
+    failed = true;
+    throw error;
   } finally {
     clearTimeout(totalTimer);
-    await client.stop();
+    try { await client.stop(); } catch (error) {
+      if (!failed) throw errorEvidence.has(error) ? error : canaryError('process_write', 'MCP child shutdown failed');
+    }
   }
 }
 
@@ -354,7 +492,8 @@ if (require.main === module) {
   runCanary().then((result) => {
     process.stdout.write(`${JSON.stringify(result)}\n`);
   }).catch((error) => {
-    process.stderr.write(`MCP_CONTROL_PATH_CANARY=FAIL ${error instanceof Error ? error.message : 'unknown_error'}\n`);
+    process.stdout.write(`${serializeFailure(error)}\n`);
+    process.stderr.write('MCP_CONTROL_PATH_CANARY=FAIL\n');
     process.exitCode = 1;
   });
 }
@@ -367,4 +506,5 @@ module.exports = {
   latencyGroup,
   percentile,
   runCanary,
+  serializeFailure,
 };

package/scripts/mcp-registry-verify.cjs

@@ -5,32 +5,52 @@ const path = require('node:path')
 
 const root = path.resolve(__dirname, '..')
 const server = JSON.parse(fs.readFileSync(path.join(root, 'server.json'), 'utf8'))
-const endpoint = new URL('https://registry.modelcontextprotocol.io/v0.1/servers')
-endpoint.searchParams.set('search', server.name)
+const endpoint = new URL(
+  `https://registry.modelcontextprotocol.io/v0.1/servers/${encodeURIComponent(server.name)}/versions/${encodeURIComponent(server.version)}`,
+)
 
 function identity(entry) {
   const candidate = entry && typeof entry === 'object' && entry.server && typeof entry.server === 'object'
     ? entry.server
     : entry
-  return {
-    name: candidate && typeof candidate.name === 'string' ? candidate.name : '',
-    version: candidate && typeof candidate.version === 'string' ? candidate.version : '',
-  }
+  if (!candidate || typeof candidate !== 'object' || Array.isArray(candidate)
+    || typeof candidate.name !== 'string' || candidate.name.length === 0
+    || typeof candidate.version !== 'string' || candidate.version.length === 0) return null
+  return { name: candidate.name, version: candidate.version }
 }
 
-async function main() {
-  const response = await fetch(endpoint, { headers: { Accept: 'application/json' }, signal: AbortSignal.timeout(10_000) })
+async function verifyRegistry(fetchImpl = globalThis.fetch) {
+  let response
+  try {
+    response = await fetchImpl(endpoint, { headers: { Accept: 'application/json' }, signal: AbortSignal.timeout(10_000) })
+  } catch {
+    throw new Error('MCP Registry query is unavailable')
+  }
   if (!response.ok) throw new Error(`MCP Registry query failed with HTTP ${response.status}`)
-  const body = await response.json()
-  const entries = Array.isArray(body?.servers) ? body.servers : []
-  const match = entries.map(identity).find((entry) => entry.name === server.name && entry.version === server.version)
-  if (!match) {
-    throw new Error(`MCP Registry is missing ${server.name}@${server.version}`)
+  let body
+  try {
+    body = await response.json()
+  } catch {
+    throw new Error('MCP Registry response is malformed')
   }
+  const match = identity(body)
+  if (!match) throw new Error('MCP Registry response is malformed')
+  if (match.name !== server.name || match.version !== server.version) {
+    throw new Error('MCP Registry identity mismatch')
+  }
+  return match
+}
+
+async function main() {
+  const match = await verifyRegistry()
   console.log(`MCP_REGISTRY_VERIFY=PASS name=${match.name} version=${match.version}`)
 }
 
-main().catch((error) => {
-  console.error(`MCP_REGISTRY_VERIFY=FAIL reason=${error instanceof Error ? error.message : String(error)}`)
-  process.exitCode = 1
-})
+if (require.main === module) {
+  main().catch((error) => {
+    console.error(`MCP_REGISTRY_VERIFY=FAIL reason=${error instanceof Error ? error.message : String(error)}`)
+    process.exitCode = 1
+  })
+}
+
+module.exports = { endpoint, identity, verifyRegistry }

package/server.json

@@ -6,12 +6,12 @@
     "url": "https://github.com/getmarrow/marrow-mcp",
     "source": "github"
   },
-  "version": "3.9.80",
+  "version": "3.9.81",
   "packages": [
     {
       "registryType": "npm",
       "identifier": "@getmarrow/mcp",
-      "version": "3.9.80",
+      "version": "3.9.81",
       "transport": {
         "type": "stdio"
       },