io.github.nicglazkov/commutescout

version 2.126.1

scanned 2026-10-16
source github.com/nicglazkov/commutescout
commit 48de6cefc84d
transport streamable-http
files read 117
methodology 0.2.0
ruleset 0.1.1

Code Safetyweight 30

79measured on 99% of this axis

1 vendored or minified path was excluded before scanning; machine-generated bundles are not the server's own code; 1 file could not be parsed and was not scanned

Auth Postureweight 20

74measured on 80% of this axis

Dependency Healthweight 20

Maintenanceweight 15

100measured on 50% of this axis

Transparencyweight 15

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

src/ca_roads_demo/static/map-app.js:1498mcp-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 counts = {};
  for (const g of groups) { ambient[g].clearLayers(); items[g] = []; }
  if (groups.includes('camera')) { cameraCache = []; signCache = []; }
  if (groups.some((g) => g.startsWith('clo_') || g === 'toll')) {
```

scripts/build_mapstyles.mjs:68mcp-js-ssrf-nonliteral-url (medium/low)

An outbound request is made to a URL that is not a literal. If any part is caller-supplied the server can be aimed at internal hosts it can reach and the caller cannot.


for (const name of ["positron", "bright"]) {
  const style = await (await fetch("https://tiles.openfreemap.org/styles/" + name)).json();
  style.name = "commutescout-" + name;
  style.layers = style.layers.filter((l) => !/^poi/.test(l.id) && l["source-layer"] !== "poi");

site/components/marketplace.tsx:136mcp-js-ssrf-nonliteral-url (medium/low)
An outbound request is made to a URL that is not a literal. If any part is caller-supplied the server can be aimed at internal hosts it can reach and the caller cannot.
```
    );
    const extra = wanted
      ? fetch("/api/flare/sources?id=" + encodeURIComponent(wanted), { headers })
          .then((r) => (r.ok ? r.json() : { sources: [] }))
          .catch(() => ({ sources: [] }))
```
site/components/turnstile-widget.tsx:103mcp-js-ssrf-nonliteral-url (medium/low)
An outbound request is made to a URL that is not a literal. If any part is caller-supplied the server can be aimed at internal hosts it can reach and the caller cannot.
```
      let next: Status;
      try {
        const resp = await fetch(form.action, { method: "POST", body });
        if (resp.ok) {
          form.reset();
```
src/ca_roads_demo/static/map-app.js:1239mcp-js-ssrf-nonliteral-url (medium/low)
An outbound request is made to a URL that is not a literal. If any part is caller-supplied the server can be aimed at internal hosts it can reach and the caller cannot.
```
  await Promise.all(cells.map(async ([k, la, lo]) => {
    try {
      const res = await fetch('/api/mapdata?bbox=' + la + ',' + lo + ',' +
        (la + 2) + ',' + (lo + 2) + '&kinds=closure,toll&fields=geo',
        { cache: 'no-cache' });
```
src/ca_roads_demo/static/map-app.js:1714mcp-js-ssrf-nonliteral-url (medium/low)
An outbound request is made to a URL that is not a literal. If any part is caller-supplied the server can be aimed at internal hosts it can reach and the caller cannot.
```
  const b = SNAP_BUNDLES[key];
  try {
    const res = await fetch(SNAP_BASE + '/' + b.file, { cache: 'no-cache' });
    if (res.ok) return await res.json();
  } catch (e) { /* snapshot host unreachable: fall back below */ }
```
src/ca_roads_demo/static/map-app.js:1718mcp-js-ssrf-nonliteral-url (medium/low)
An outbound request is made to a URL that is not a literal. If any part is caller-supplied the server can be aimed at internal hosts it can reach and the caller cannot.
```
  } catch (e) { /* snapshot host unreachable: fall back below */ }
  try {
    const res = await fetch('/api/mapdata?bbox=-85,-180,85,180&kinds=' +
      b.kinds + '&slim=1', { cache: 'no-cache' });
    if (!res.ok) return null;
```
src/ca_roads_demo/static/map-app.js:1915mcp-js-ssrf-nonliteral-url (medium/low)
An outbound request is made to a URL that is not a literal. If any part is caller-supplied the server can be aimed at internal hosts it can reach and the caller cannot.
```
async function fetchPluginBox(bbox) {
  const res = await fetch('/api/mapdata?bbox=' + bbox + '&kinds=plugin&slim=1', { cache: 'no-cache' });
  if (!res.ok) return null;
  return (await res.json()).markers || [];
```
src/ca_roads_demo/static/map-app.js:2402mcp-js-ssrf-nonliteral-url (medium/low)
An outbound request is made to a URL that is not a literal. If any part is caller-supplied the server can be aimed at internal hosts it can reach and the caller cannot.
```
  const mid = pts[Math.floor(pts.length / 2)];
  try {
    const res = await fetch('/api/flow?pts=' +
      mid[0].toFixed(4) + ',' + mid[1].toFixed(4));
    if (!res.ok) return;
```
src/ca_roads_demo/static/map-app.js:2591mcp-js-ssrf-nonliteral-url (medium/low)
An outbound request is made to a URL that is not a literal. If any part is caller-supplied the server can be aimed at internal hosts it can reach and the caller cannot.
```
    btn.textContent = 'Loading…'; btn.disabled = true;
    try {
      const res = await fetch('/api/incident/' + encodeURIComponent(btn.dataset.inc));
      if (!res.ok) throw new Error('unavailable');
      const d = await res.json();
```
src/ca_roads_demo/static/map-app.js:2961mcp-js-prototype-pollution-json-merge (medium/low)
A parsed JSON document is merged into an existing object. JSON.parse preserves a literal "__proto__" key, so a caller-supplied document can reach Object.prototype through Object.assign.
```
  KEY: 'cs.places.v1',
  load() {
    try { return Object.assign({ home: null, work: null, saved: [], recents: [] }, JSON.parse(store.get(this.KEY) || '{}')); }
    catch (_) { return { home: null, work: null, saved: [], recents: [] }; }
  },
```
src/ca_roads_demo/static/map-app.js:3019mcp-js-ssrf-nonliteral-url (medium/low)
An outbound request is made to a URL that is not a literal. If any part is caller-supplied the server can be aimed at internal hosts it can reach and the caller cannot.
```
      // upgrade the coordinates in place. The street point stays as the
      // fallback if interpolation finds nothing.
      fetch('/api/geocode?q=' + encodeURIComponent(c.name))
        .then(r => r.json())
        .then(d => {
```
src/ca_roads_demo/static/map-app.js:3107mcp-js-ssrf-nonliteral-url (medium/low)
An outbound request is made to a URL that is not a literal. If any part is caller-supplied the server can be aimed at internal hosts it can reach and the caller cannot.
```
    try {
      const c = map.getCenter();
      const res = await fetch('/api/suggest?q=' + encodeURIComponent(q) +
        '&lat=' + c.lat.toFixed(2) + '&lon=' + c.lng.toFixed(2),
        { signal: aborter.signal });
```
src/ca_roads_demo/static/map-app.js:3150mcp-js-ssrf-nonliteral-url (medium/low)
An outbound request is made to a URL that is not a literal. If any part is caller-supplied the server can be aimed at internal hosts it can reach and the caller cannot.
```
    val.className = 'val'; val.textContent = 'Checking address\u2026';
    try {
      const res = await fetch('/api/geocode?q=' + encodeURIComponent(q));
      const data = await res.json();
      if (mine !== vseq) return;
```

src/ca_roads_demo/static/map-app.js:3712mcp-js-ssrf-nonliteral-url (medium/low)

An outbound request is made to a URL that is not a literal. If any part is caller-supplied the server can be aimed at internal hosts it can reach and the caller cannot.

  const token = await authToken();
  if (!token) return { error: 'signin' };
  const res = await fetch(path, { method: 'POST',
    headers: { 'Content-Type': 'application/json', Authorization: 'Bearer ' + token },
    body: JSON.stringify(body) });

src/ca_roads_demo/static/map-app.js:3724mcp-js-ssrf-nonliteral-url (medium/low)

An outbound request is made to a URL that is not a literal. If any part is caller-supplied the server can be aimed at internal hosts it can reach and the caller cannot.

async function snapForReport(latlng) {
  try {
    const r = await fetch('/api/snap?lat=' + latlng.lat.toFixed(6) + '&lon=' + latlng.lng.toFixed(6));
    const d = await r.json();
    if (d && d.snapped) return Object.assign(L.latLng(d.lat, d.lon), { road: d.road || null });

src/ca_roads_demo/static/map-app.js:3876mcp-js-ssrf-nonliteral-url (medium/low)
An outbound request is made to a URL that is not a literal. If any part is caller-supplied the server can be aimed at internal hosts it can reach and the caller cannot.
```
  }
  try {
    const res = await fetch('/api/flow?pts=' + mids.join('|'));
    if (!res.ok) return;
    const data = await res.json();
```
src/ca_roads_demo/static/sw.js:52mcp-js-ssrf-nonliteral-url (medium/low)
An outbound request is made to a URL that is not a literal. If any part is caller-supplied the server can be aimed at internal hosts it can reach and the caller cannot.
```
  const cache = await caches.open(SNAP_CACHE);
  try {
    const res = await fetch(request);
    if (res && res.ok) cache.put(request, res.clone());
    return res;
```
src/ca_roads_demo/static/sw.js:80mcp-js-ssrf-nonliteral-url (medium/low)
An outbound request is made to a URL that is not a literal. If any part is caller-supplied the server can be aimed at internal hosts it can reach and the caller cannot.
```
    const hit = await cache.match(e.request);
    if (hit) return hit;
    const res = await fetch(e.request);
    if (res.ok) cache.put(e.request, res.clone());
    return res;
```
src/ca_roads_demo/static/watch-app.js:52mcp-js-ssrf-nonliteral-url (medium/low)
An outbound request is made to a URL that is not a literal. If any part is caller-supplied the server can be aimed at internal hosts it can reach and the caller cannot.
```
  async function api(path, options = {}) {
    const token = await user.getIdToken();
    const res = await fetch(path, {
      ...options,
      headers: { Authorization: 'Bearer ' + token,
```
src/ca_roads_demo/static/watch-app.js:370mcp-js-ssrf-nonliteral-url (medium/low)
An outbound request is made to a URL that is not a literal. If any part is caller-supplied the server can be aimed at internal hosts it can reach and the caller cannot.
```
  async function geocodeOne(q) {
    const res = await fetch('/api/geocode?q=' + encodeURIComponent(q));
    if (!res.ok) throw new Error('address lookup failed');
    const c = ((await res.json()).candidates || [])[0];
```

src/ca_roads_demo/watch.py:661mcp-python-ssrf-nonliteral-url (medium/low)

An outbound HTTP request is made to a URL that is not a literal. If any part of it is caller-supplied, the server can be steered at internal hosts — cloud metadata endpoints, admin ports, other tenants.

        "apns": {"payload": {"aps": {"sound": "default"}}},
    }
    r = httpx.post(FCM_URL.format(project=PROJECT), json={"message": msg},
                   headers={"Authorization": f"Bearer {bearer}"}, timeout=15)
    if r.status_code == 404 or (r.status_code == 400 and "UNREGISTERED" in r.text):

Auth Posture

authentication_model
source reads a credential header but no enforcing middleware or rejection path was found — `03` §4's "present but optional or trivially bypassable" band
transport_security
declared endpoint(s) are HTTPS: https://mcp.commutescout.com/mcp; scored 80, not 100: `03` §4 reserves 100 for HTTPS *with HSTS*, and an HSTS header can only be seen by connecting, which `04` §9 does not do. This is an unverifiable band, not an observed absence.
secret_handling
detect-secrets matched 12 credential-shaped string(s), every one from a keyword or entropy heuristic (Base64 High Entropy String, Hex High Entropy String, Secret Keyword). Those flag placeholders, variable names and content hashes as readily as credentials, so they do not establish the committed credential `03` §4's 0 asserts, and this sub-check is not scored; Hex High Entropy String at evals/results/history.jsonl:1; Hex High Entropy String at site/app/layout.tsx:98; Base64 High Entropy String at src/ca_roads_demo/states.py:1341; Hex High Entropy String at src/ca_roads_demo/static/admin.html:553; Hex High Entropy String at src/ca_roads_demo/static/map.html:515; Hex High Entropy String at src/ca_roads_demo/static/trip.html:235; Hex High Entropy String at src/ca_roads_demo/static/watch.html:399; Base64 High Entropy String at src/ca_roads_demo/watch.py:49; Base64 High Entropy String at src/ca_roads_mcp/rest.py:160; Secret Keyword at tests/test_contact.py:162; …and 2 more matches
authorization_granularity
10 tool registrations with conditional access logic present in the same source

Dependency Health

site/package-lock.jsonnext 16.3.7 — GHSA-cjq9-62q9-8jv4
direct, CVSS 8.3, fixed in 16.3.8
https://osv.dev/vulnerability/GHSA-cjq9-62q9-8jv4
site/package-lock.jsonbraces 3.0.3 — GHSA-vfj7-8cjw-p6xm
transitive, CVSS 8.7
https://osv.dev/vulnerability/GHSA-vfj7-8cjw-p6xm
site/package-lock.jsonnext 16.3.7 — GHSA-3w37-wq28-93x7
direct, CVSS 6.3, fixed in 16.3.8
https://osv.dev/vulnerability/GHSA-3w37-wq28-93x7
site/package-lock.jsonnext 16.3.7 — GHSA-4jqv-mc3x-m676
direct, CVSS 6.3, fixed in 16.3.8
https://osv.dev/vulnerability/GHSA-4jqv-mc3x-m676
site/package-lock.jsonnext 16.3.7 — GHSA-f87g-xv8r-7p7x
direct, CVSS 6.3, fixed in 16.3.8
https://osv.dev/vulnerability/GHSA-f87g-xv8r-7p7x
site/package-lock.jsonnext 16.3.7 — GHSA-mcj8-r9mp-w47p
direct, CVSS 6.3, fixed in 16.3.8
https://osv.dev/vulnerability/GHSA-mcj8-r9mp-w47p
site/package-lock.jsonnext 16.3.7 — GHSA-39w2-rjm5-chcv
direct, CVSS 5.4, fixed in 16.3.8
https://osv.dev/vulnerability/GHSA-39w2-rjm5-chcv

Maintenance

recency
last commit 9 day(s) before 2026-10-16
issue_responsiveness
every issue read was filed by the project itself (6 by its maintainers or bots), so none is someone outside waiting for an answer, and `03` §5's question — will anyone read an issue I file? — has nothing to measure.
release_cadence
released 9 day(s) ago (by releases), inside `03` §5's 30-day window
bus_factor
this repository's 12-month history is longer than the bounded walk `04` §7 performs, and the authors found so far span more than one of `03` §5's bands. A limit of ours, not a finding about the server.
repository_signals
`03` §5 scores this by quartile WITHIN the server's category, which needs a distribution across every scanned server and so cannot be computed while scanning one. It is a post-pass over the crawl and that pass does not exist yet.

Transparency

license
LICENSE present with no SPDX-License-Identifier tag; identified as 'MIT' from its text
readme_quality
README.md: configuration documented (+25), states what the server does in the first 200 words (+20)
declared_scopes
neither the README nor the MCP manifest documents what the server accesses or what side effects it has
changelog
no CHANGELOG in the fetched source. `03` §7's partial credit for tagged releases carrying release notes is not applied here — that needs the forge API, which this check does not call
security_contact
SECURITY.md present

Contest a finding

Every number here comes from a rule reading published source, and rules get things wrong. If something on this page is incorrect — or correct but mitigated by a check the rule cannot see — open an issue and we answer it in writing. A finding we got wrong is removed and the rule is fixed; one that stands is answered on the record.

Anyone can file: the maintainer, a researcher who disagrees with the classification, or a user who tested the server and could not reproduce it. Name this server and the rule or advisory ID shown beside the finding above. We aim to reply within five business days and to resolve within ten.

Open an appeal on GitHub