@reproapp/mcp 0.0.6 → 0.0.8

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@reproapp/mcp",
-  "version": "0.0.6",
+  "version": "0.0.8",
   "description": "Repro MCP server for AI-assisted debugging and privacy policy workflows",
   "license": "MIT",
   "type": "commonjs",

package/src/index.js

@@ -1192,9 +1192,10 @@ async function executeTool(params, config, client, getTools) {
     throw rpcError(-32602, `Unknown tool: ${name}`);
   }
 
-  const response = await client.executeTool(name, input);
+  const response = await client.executeTool(name, inputWithExactCapturedPayloads(name, input));
+  const expandedResponse = await expandLinkedCapturedPayloads(name, response, client, input);
 
-  const augmented = augmentPaths(response, config.pathMappings);
+  const augmented = augmentPaths(expandedResponse, config.pathMappings);
   const isError =
     augmented &&
     typeof augmented === 'object' &&
@@ -1213,6 +1214,189 @@ async function executeTool(params, config, client, getTools) {
   };
 }
 
+function inputWithExactCapturedPayloads(name, input) {
+  if (name !== 'get_kafka_messages') {
+    return input;
+  }
+  return {
+    ...input,
+    includeLargeValues: true,
+    expandLargeValue: true,
+  };
+}
+
+async function expandLinkedCapturedPayloads(name, response, client, originalInput = {}) {
+  if (name !== 'get_kafka_messages') {
+    return response;
+  }
+
+  const root = cloneJson(response) ?? response;
+  const visited = new Set();
+
+  while (true) {
+    const links = collectCapturedPayloadLinks(root)
+      .filter((entry) => !visited.has(capturedPayloadLinkKey(entry.link)));
+    if (!links.length) {
+      return root;
+    }
+
+    for (const { link } of links) {
+      const key = capturedPayloadLinkKey(link);
+      visited.add(key);
+
+      const toolName = typeof link.tool === 'string' ? link.tool : '';
+      if (toolName !== 'get_kafka_messages') {
+        throw new Error(`Cannot expand captured payload through unsupported MCP tool: ${toolName || 'unknown'}`);
+      }
+
+      const linkArgs = link.arguments && typeof link.arguments === 'object' && !Array.isArray(link.arguments)
+        ? link.arguments
+        : {};
+      const scopedLinkArgs = {
+        ...originalInput,
+        ...linkArgs,
+      };
+      const expanded = await client.executeTool(toolName, inputWithExactCapturedPayloads(toolName, scopedLinkArgs));
+      const expandedLookup = lookupLinkedPayloadValue(expanded, link.path);
+      if (!expandedLookup.found) {
+        throw new Error(`Repro MCP could not expand captured payload at ${link.path || 'unknown path'}`);
+      }
+
+      const applied = replaceLinkedPayloadValue(root, link.path, expandedLookup.value);
+      if (!applied) {
+        throw new Error(`Repro MCP could not replace captured payload at ${link.path || 'unknown path'}`);
+      }
+    }
+  }
+}
+
+function collectCapturedPayloadLinks(value, out = []) {
+  if (!value || typeof value !== 'object') {
+    return out;
+  }
+  if (Array.isArray(value)) {
+    for (const item of value) {
+      collectCapturedPayloadLinks(item, out);
+    }
+    return out;
+  }
+
+  const link = value.valueOmitted === true ? value.valueLink : value.rawValueLink;
+  if (
+    (value.valueOmitted === true || value.rawValueOmitted === true) &&
+    link &&
+    typeof link === 'object' &&
+    link.kind === 'mcp-tool-call' &&
+    typeof link.tool === 'string' &&
+    typeof link.path === 'string'
+  ) {
+    out.push({ holder: value, link });
+  }
+
+  for (const nested of Object.values(value)) {
+    collectCapturedPayloadLinks(nested, out);
+  }
+  return out;
+}
+
+function capturedPayloadLinkKey(link) {
+  return JSON.stringify({
+    tool: link?.tool ?? null,
+    path: link?.path ?? null,
+    arguments: link?.arguments ?? null,
+  });
+}
+
+function lookupLinkedPayloadValue(root, pathExpression) {
+  const segments = parseLinkedPayloadPath(pathExpression);
+  if (!segments.length) {
+    return { found: false };
+  }
+  return lookupPathCandidates(root, segments);
+}
+
+function replaceLinkedPayloadValue(root, pathExpression, value) {
+  const segments = parseLinkedPayloadPath(pathExpression);
+  if (!segments.length) {
+    return false;
+  }
+  const candidates = pathCandidateSegments(segments);
+  for (const candidate of candidates) {
+    const parentLookup = getAtPath(root, candidate.slice(0, -1));
+    if (!parentLookup.found || !parentLookup.value || typeof parentLookup.value !== 'object') {
+      continue;
+    }
+    const leaf = candidate[candidate.length - 1];
+    parentLookup.value[leaf] = value;
+    if (leaf === 'value') {
+      delete parentLookup.value.valueOmitted;
+      delete parentLookup.value.valuePreview;
+      delete parentLookup.value.valueLink;
+    } else if (leaf === 'rawValue') {
+      delete parentLookup.value.rawValueOmitted;
+      delete parentLookup.value.rawValuePreview;
+      delete parentLookup.value.rawValueLink;
+    }
+    return true;
+  }
+  return false;
+}
+
+function lookupPathCandidates(root, segments) {
+  for (const candidate of pathCandidateSegments(segments)) {
+    const lookup = getAtPath(root, candidate);
+    if (lookup.found) {
+      return lookup;
+    }
+  }
+  return { found: false };
+}
+
+function pathCandidateSegments(segments) {
+  return [
+    ['data', ...segments],
+    segments,
+  ];
+}
+
+function parseLinkedPayloadPath(pathExpression) {
+  if (typeof pathExpression !== 'string' || !pathExpression.trim()) {
+    return [];
+  }
+  const segments = [];
+  const pattern = /([A-Za-z_$][\w$-]*)|\[(\d+)\]/g;
+  let match;
+  while ((match = pattern.exec(pathExpression)) !== null) {
+    if (typeof match[1] === 'string') {
+      segments.push(match[1]);
+    } else if (typeof match[2] === 'string') {
+      segments.push(Number.parseInt(match[2], 10));
+    }
+  }
+  return segments;
+}
+
+function getAtPath(root, segments) {
+  let current = root;
+  for (const segment of segments) {
+    if (current == null) {
+      return { found: false };
+    }
+    if (typeof segment === 'number') {
+      if (!Array.isArray(current) || segment < 0 || segment >= current.length) {
+        return { found: false };
+      }
+      current = current[segment];
+      continue;
+    }
+    if (typeof current !== 'object' || !Object.prototype.hasOwnProperty.call(current, segment)) {
+      return { found: false };
+    }
+    current = current[segment];
+  }
+  return { found: true, value: current };
+}
+
 function formatLocalToolContentText(name, value) {
   if (name === 'inspect_privacy_policy' || name === 'list_privacy_policy_blockers') {
     const text = renderPolicyInspectionText(value);
@@ -1222,6 +1406,9 @@ function formatLocalToolContentText(name, value) {
     const text = renderPrivacyCoverageText(value);
     if (text) return text;
   }
+  if (name === 'get_kafka_messages') {
+    return JSON.stringify(value, null, 2);
+  }
   return JSON.stringify(value, null, 2);
 }