@getmarrow/mcp 3.9.80 → 3.9.82

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,108 @@ 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 autoTimings(payload) {
+  const result = {};
+  for (const [group, fields] of [
+    ['phase_timings_ms', ['runtime', 'think', 'commit', 'total']],
+    ['response_timings_ms', ['core', 'durable_enqueue', 'full_response']],
+  ]) {
+    const source = payload?.[group];
+    if (!source || typeof source !== 'object' || Array.isArray(source)) continue;
+    const values = {};
+    for (const field of fields) {
+      const value = source[field];
+      if (typeof value === 'number' && Number.isFinite(value) && value >= 0 && value <= 60000) {
+        values[field] = Math.round(value);
+      }
+    }
+    if (Object.keys(values).length) result[group] = values;
+  }
+  return result;
+}
+
+function autoWaitClass(payload) {
+  if (payload?.live_delivery?.committed !== false
+    || typeof payload.live_delivery.accepted !== 'boolean'
+    || typeof payload.resumable !== 'boolean') return null;
+  if (['runtime_pending', 'think_pending', 'commit_pending'].includes(payload.phase)
+    && payload.completion_state === 'delivery_pending' && payload.resumable === true) return 'completion_pending';
+  if ((payload.phase === 'owner_approval_required' && payload.completion_state === 'pending_owner_approval'
+    || payload.phase === 'review_required' && payload.completion_state === 'review_required_terminal')
+    && payload.resumable === false) return 'approval_required';
+  if (payload.phase === 'proof_required' && payload.completion_state === 'pending_required_proof') return 'proof_required';
+  return null;
+}
+
+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),
+    ...(row.tool === 'marrow_auto' ? {
+      ...autoTimings(row), attempts: row.attempts, retry_wait_ms: safeMs(row.retry_wait_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),
+    ...(context.tool === 'marrow_auto' ? {
+      ...autoTimings(context.autoMetrics), retry_wait_ms: safeMs(context.retryWaitMs),
+      ...(context.autoPhase ? { auto_phase: context.autoPhase } : {}),
+    } : {}),
+    ...(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 +183,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(
@@ -117,6 +226,26 @@ function validatePayload(name, payload) {
       'runtime gate',
     );
   } else if (name === 'marrow_auto') {
+    const failure = payload.live_delivery?.failure;
+    if (failure) {
+      requireField(payload.live_delivery.committed === false && payload.phase == null
+        && failure.ok === false, 'failed auto delivery');
+      // Transport/auth status takes precedence over a caller-facing proof label.
+      const category = failure.error?.category;
+      const categories = {
+        authentication_required: 'authentication', permission_denied: 'authorization',
+        proof_required: 'proof_required', request_timeout: 'request_timeout',
+        dns_unavailable: 'tool_unavailable', connection_reset: 'tool_unavailable',
+        tls_failure: 'tool_unavailable', edge_access_denied: 'tool_unavailable',
+        service_unavailable: 'tool_unavailable', rate_limited: 'tool_unavailable',
+        request_failed: 'tool_unavailable', invalid_response: 'contract',
+      };
+      const classification = typeof category === 'string' && Object.hasOwn(categories, category)
+        ? categories[category] : 'contract';
+      throw upstreamError(failure, classification, 'Auto delivery failed');
+    }
+    const waitClass = autoWaitClass(payload);
+    if (waitClass) throw canaryError(waitClass, 'Auto completion is awaiting its declared next step');
     requireField(
       payload.live_delivery
         && payload.live_delivery.accepted === true
@@ -160,27 +289,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 +327,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 +349,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 +385,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 +414,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,46 +466,80 @@ 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;
+      let attempts = 0;
+      context.retryWaitMs = 0;
+      context.autoMetrics = undefined;
+      context.autoPhase = undefined;
       for (let attempt = 0; attempt < 3; attempt += 1) {
+        if (client.fatalError) throw client.fatalError;
+        stage('tool_call', name, attempt + 1);
+        attempts += 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 (name !== 'marrow_auto') break;
+        context.autoMetrics = autoTimings(payload);
+        const waitClass = autoWaitClass(payload);
+        context.autoPhase = waitClass ? payload.phase : undefined;
+        if (waitClass !== 'completion_pending') break;
         if (attempt < 2) {
-          const retryAfterMs = Number(payload.retry_after_ms);
-          const delayMs = Number.isFinite(retryAfterMs) ? Math.max(0, Math.min(1_000, retryAfterMs)) : 250;
+          const requested = payload.retry_after_ms;
+          const delayMs = typeof requested === 'number' && Number.isFinite(requested) && requested >= 0
+            ? Math.ceil(requested) : 250;
+          const remaining = totalTimeoutMs - (performance.now() - context.started);
+          if (delayMs >= remaining) break;
+          const waitStarted = performance.now();
           await new Promise((resolveDelay) => setTimeout(resolveDelay, delayMs));
+          context.retryWaitMs += Math.round(performance.now() - waitStarted);
         }
       }
       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`);
-      results.push({ tool: name, ok: true, live: true, latency_ms: latencyMs });
+      if (!live) throw canaryError('contract', `${name} returned cached or unavailable guidance`);
+      results.push({ tool: name, ok: true, live: true, latency_ms: latencyMs,
+        ...(name === 'marrow_auto' ? { ...autoTimings(payload), attempts, retry_wait_ms: context.retryWaitMs } : {}),
+      });
     }
     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 +553,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 +568,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 +582,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.82",
   "packages": [
     {
       "registryType": "npm",
       "identifier": "@getmarrow/mcp",
-      "version": "3.9.80",
+      "version": "3.9.82",
       "transport": {
         "type": "stdio"
       },