com.averray/mcp

version 1.1.0

scanned 2026-10-16
source github.com/averray-agent/agent
commit 039764842f3a
transport streamable-http
files read 1397
methodology 0.2.0
ruleset 0.1.1

No tag matching version 1.1.0 was found in this repository, so the scan read the default branch instead. The findings below describe that code, not necessarily the released version.

Code Safetyweight 30

68measured on 99% of this axis

66 findings in test code are listed but not deducted; 46 vendored or minified paths were excluded before scanning; machine-generated bundles are not the server's own code; 2 files could not be parsed and were not scanned

Auth Postureweight 20

71measured on 85% of this axis

Dependency Healthweight 20

Maintenanceweight 15

68measured on 55% of this axis

Transparencyweight 15

25measured on 80% of this axis

The evidence

Every deduction below names the artefact that produced it. Nothing on this page was executed: the source was read, never run, and no running server was contacted.

Code Safety

Showing the 50 most severe of 110 findings on this axis. The score was computed over all of them — findings beyond the fourth of a severity still deduct at a tenth of their weight — so the remainder is omitted from this page, not from the arithmetic.

app/handoffs/averray-mobile-operator-control/project/support.js:71mcp-js-prototype-pollution-merge-loop (medium/medium)
Keys from a caller-supplied object are copied onto a target without excluding __proto__ / constructor / prototype. A tool argument carrying __proto__ then mutates Object.prototype for the whole process, which can turn an unrelated later property read into attacker-controlled data.
```
    const rest = {};
    for (const k of Object.keys(obj)) {
      if (k[0] !== "$") rest[k] = obj[k];
    }
    return { props: Object.keys(rest).length ? rest : null, preview };
```
app/handoffs/averray-mobile-operator-control/project/support.js:189mcp-js-prototype-pollution-merge-loop (medium/medium)
Keys from a caller-supplied object are copied onto a target without excluding __proto__ / constructor / prototype. A tool argument carrying __proto__ then mutates Object.prototype for the whole process, which can turn an unrelated later property read into attacker-controlled data.
```
        for (const k in entry.propsMeta || {}) {
          const v = entry.propsMeta?.[k]?.default;
          if (v !== void 0) d[k] = v;
        }
        return d;
```
app/handoffs/averray-mobile-operator-control/project/support.js:1227mcp-js-prototype-pollution-merge-loop (medium/medium)
Keys from a caller-supplied object are copied onto a target without excluding __proto__ / constructor / prototype. A tool argument carrying __proto__ then mutates Object.prototype for the whole process, which can turn an unrelated later property read into attacker-controlled data.
```
        for (const k of Object.keys(window)) {
          if (!before.has(k) && typeof window[k] === "function") {
            globals[k] = window[k];
          }
        }
```
mcp-server/src/core/agent-profile.js:305mcp-js-prototype-pollution-merge-loop (medium/medium)
Keys from a caller-supplied object are copied onto a target without excluding __proto__ / constructor / prototype. A tool argument carrying __proto__ then mutates Object.prototype for the whole process, which can turn an unrelated later property read into attacker-controlled data.
```
    }
    for (const key of Object.keys(totals)) {
      totals[key] += Number.isInteger(signals[key]) ? signals[key] : 0;
    }
  }
```
mcp-server/src/core/job-catalog-normalization.js:332mcp-js-prototype-pollution-merge-loop (medium/medium)
Keys from a caller-supplied object are copied onto a target without excluding __proto__ / constructor / prototype. A tool argument carrying __proto__ then mutates Object.prototype for the whole process, which can turn an unrelated later property read into attacker-controlled data.
```
        throw new ValidationError(`schedule.${key} must be ISO-8601 if provided`);
      }
      normalised[key] = new Date(parsed).toISOString();
    }
  }
```
mcp-server/src/core/job-catalog-normalization.js:505mcp-js-prototype-pollution-merge-loop (medium/medium)
Keys from a caller-supplied object are copied onto a target without excluding __proto__ / constructor / prototype. A tool argument carrying __proto__ then mutates Object.prototype for the whole process, which can turn an unrelated later property read into attacker-controlled data.
```
  for (const key of ["pausedAt", "archivedAt", "reopenedAt"]) {
    if (typeof raw[key] === "string" && raw[key].trim()) {
      lifecycle[key] = normalizeIsoTimestamp(raw[key], `lifecycle.${key}`);
    }
  }
```
mcp-server/src/core/job-catalog-normalization.js:510mcp-js-prototype-pollution-merge-loop (medium/medium)
Keys from a caller-supplied object are copied onto a target without excluding __proto__ / constructor / prototype. A tool argument carrying __proto__ then mutates Object.prototype for the whole process, which can turn an unrelated later property read into attacker-controlled data.
```
  for (const key of ["reason", "staleReason"]) {
    if (typeof raw[key] === "string" && raw[key].trim()) {
      lifecycle[key] = raw[key].trim().slice(0, 500);
    }
  }
```
mcp-server/src/core/work-receipt.js:113mcp-js-prototype-pollution-merge-loop (medium/medium)
Keys from a caller-supplied object are copied onto a target without excluding __proto__ / constructor / prototype. A tool argument carrying __proto__ then mutates Object.prototype for the whole process, which can turn an unrelated later property read into attacker-controlled data.
```
      throw new ValidationError(`Verdict-core commitment requires root section ${section}.`);
    }
    verdictCore[section] = value;
  }
  return hashCanonicalContent(verdictCore);
```
mcp-server/src/services/arrival-dropoff.js:220mcp-js-prototype-pollution-merge-loop (medium/medium)
Keys from a caller-supplied object are copied onto a target without excluding __proto__ / constructor / prototype. A tool argument carrying __proto__ then mutates Object.prototype for the whole process, which can turn an unrelated later property read into attacker-controlled data.
```
    for (const actor of DROP_OFF_ACTORS) {
      for (const stage of ARRIVAL_STAGES) {
        totals[door][actor][stage] = topCodes(totals[door][actor][stage]);
      }
    }
```
mcp-server/src/services/arrival-observatory.js:886mcp-js-prototype-pollution-merge-loop (medium/medium)
Keys from a caller-supplied object are copied onto a target without excluding __proto__ / constructor / prototype. A tool argument carrying __proto__ then mutates Object.prototype for the whole process, which can turn an unrelated later property read into attacker-controlled data.
```
      }
      for (const source of ATTRIBUTION_SOURCES) {
        current.attributionSources[source] += Number(entry.attributionSources?.[source] ?? 0);
      }
      current.doors = [...new Set([
```
mcp-server/src/services/arrival-observatory.js:1204mcp-js-prototype-pollution-merge-loop (medium/medium)
Keys from a caller-supplied object are copied onto a target without excluding __proto__ / constructor / prototype. A tool argument carrying __proto__ then mutates Object.prototype for the whole process, which can turn an unrelated later property read into attacker-controlled data.
```
  for (const source of ATTRIBUTION_SOURCES) {
    if (Number.isFinite(Number(stored?.[source]))) {
      target[source] = Number(stored[source]);
    }
  }
```
mcp-server/src/services/arrival-operator-view.js:202mcp-js-prototype-pollution-merge-loop (medium/medium)
Keys from a caller-supplied object are copied onto a target without excluding __proto__ / constructor / prototype. A tool argument carrying __proto__ then mutates Object.prototype for the whole process, which can turn an unrelated later property read into attacker-controlled data.
```
        current.doors.add(door);
        const reached = hasReachedSessionStage(session, "submitted") ? "submitted" : "claimed";
        if (stageRank(reached) > stageRank(current.doorFurthest[door])) current.doorFurthest[door] = reached;
      }
    }
```
mcp-server/src/services/bootstrap.js:1606mcp-js-prototype-pollution-merge-loop (medium/medium)
Keys from a caller-supplied object are copied onto a target without excluding __proto__ / constructor / prototype. A tool argument carrying __proto__ then mutates Object.prototype for the whole process, which can turn an unrelated later property read into attacker-controlled data.
```
  ]) {
    if (xcm[key] !== undefined) {
      normalized[key] = xcm[key];
    }
  }
```
mcp-server/src/services/deposit-pool-observability.js:44mcp-js-prototype-pollution-merge-loop (medium/medium)
Keys from a caller-supplied object are copied onto a target without excluding __proto__ / constructor / prototype. A tool argument carrying __proto__ then mutates Object.prototype for the whole process, which can turn an unrelated later property read into attacker-controlled data.
```
  };
  for (const key of ["assetsRaw", "sharesRaw", "requestId", "tier", "unlockAt"]) {
    if (event[key] !== undefined && event[key] !== null) common[key] = String(event[key]);
  }
  return common;
```

app/handoffs/averray-mobile-operator-control/project/support.js:159mcp-js-ssrf-nonliteral-url (medium/low)