io.github.yeyuan98/biomcp-ts

version 1.4.3

scanned 2026-10-16
source github.com/yeyuan98/biomcp-ts
commit a71238a40b87
transport stdio
files read 284
methodology 0.2.0
ruleset 0.1.1

Code Safetyweight 30

44measured on 97% of this axis

scored on the declared repository at version 1.4.3, because the published package carries its code only as build output, which is not read as the server's own source; 26 findings in test code are listed but not deducted; 4 files could not be parsed and were not scanned

Auth Postureweight 20

100measured on 65% of this axis

Dependency Healthweight 20

not assessed

no lockfile in the fetched source; dependency versions are unresolved, so no vulnerability can be attributed

Maintenanceweight 15

97measured on 90% of this axis

Transparencyweight 15

53measured 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

docs/development/biowasm-prototype/heal.mjs:35mcp-js-shell-exec-nonliteral (critical/medium)

A shell is spawned on a value that is not a string literal. child_process .exec and execSync run their argument through /bin/sh, so any caller-supplied component is shell syntax, not data.

  if (!v.bad) { console.log('VALID after', round - 1, 'patches; size', buf.length); writeFileSync(HOST, buf); process.exit(0); }
  console.log(`round ${round}: corrupt at ${v.bad} (${v.why}); fetching range ${v.bad}-${v.bad + 65535}`);
  const range = execSync(`curl -s -r ${v.bad}-${v.bad + 65535} "${URL}"`);
  console.log('  got', range.length, 'bytes');
  buf.set(range.subarray(0, Math.min(range.length, buf.length - v.bad)), v.bad);

docs/development/biowasm-prototype/heal.mjs:35mcp-js-shell-exec-template-literal (critical/medium)

A shell command is built from a template literal with interpolation. Quoting inside a template does not escape shell metacharacters.

  if (!v.bad) { console.log('VALID after', round - 1, 'patches; size', buf.length); writeFileSync(HOST, buf); process.exit(0); }
  console.log(`round ${round}: corrupt at ${v.bad} (${v.why}); fetching range ${v.bad}-${v.bad + 65535}`);
  const range = execSync(`curl -s -r ${v.bad}-${v.bad + 65535} "${URL}"`);
  console.log('  got', range.length, 'bytes');
  buf.set(range.subarray(0, Math.min(range.length, buf.length - v.bad)), v.bad);

scripts/biowasm/pin-assets.mjs:78mcp-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 buf = await fetchWithRetries(`${CDN}/${tool}/${spec.version}/${file}`);
      await validate(tool, file, buf, glueSize);
      hashes[file] = createHash('sha256').update(buf).digest('hex');
      writeFileSync(join(work, file), buf);
      process.stdout.write(`ok (${buf.length} bytes)\n`);
```
scripts/external-databases/depmap/ingest.ts:104mcp-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.
```
      header = row;
      for (const col of GENE_REQUIRED_COLUMNS) {
        idx[col] = header.indexOf(col);
        if (idx[col] === -1) throw new Error(`Gene.csv is missing required column "${col}"`);
      }
```
src/biowasm/registry.ts: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.
```
        throw fail(`${validation.reason}; set ${MIRROR_ENV_VAR} to provision from a trusted mirror`);
      }
      files[file] = buf;
    }
  }
```
src/biowasm/registry.ts:229mcp-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 files: Record<string, string> = {};
  for (const file of expectedAssetFileNames()) {
    files[file] = sha256File(join(dir, file));
  }
  writeFileSync(
```
src/entities/patent/search/index.ts:223mcp-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 total_hits_basis: PatentSearchResponse['total_hits_basis'] = {};
  for (const source of Object.keys(total_hits) as PatentSource[]) {
    total_hits_basis[source] = TOTAL_HITS_BASIS[source];
  }
```
src/server/tools/drug.ts:67mcp-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 (!data || typeof data !== 'object') continue;
            if (Array.isArray(data)) {
              result.sections[name_] = data.slice(0, limit);
            } else if (DRUG_ARRAY_KEYS[name_]) {
              const keys = DRUG_ARRAY_KEYS[name_];
```
src/server/tools/drug.ts:72mcp-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 obj = data as Record<string, unknown>;
              for (const k of keys) {
                if (Array.isArray(obj[k])) obj[k] = obj[k].slice(0, limit);
              }
            } else {
```
src/server/tools/drug.ts:75mcp-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.
```
              }
            } else {
              result.sections[name_] = sliceArraysRecursive(data, limit);
            }
          }
```
src/server/tools/utils.ts:41mcp-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 obj = data as Record<string, unknown>;
      for (const k of keys) {
        if (Array.isArray(obj[k])) obj[k] = obj[k].slice(0, limit);
      }
    }
```
scripts/biowasm/pin-assets.mjs:28mcp-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 (let attempt = 1; attempt <= FETCH_ATTEMPTS; attempt++) {
    try {
      const res = await fetch(url, {
        signal: AbortSignal.timeout(FETCH_TIMEOUT_MS),
        headers: { 'User-Agent': 'biomcp-pin-assets' },
```
src/biowasm/registry.ts:308mcp-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.
```
export async function provisionBiowasmAssets(
  fetchImpl: BiowasmFetch = (url) =>
    fetch(url, {
      headers: { 'User-Agent': 'biomcp-biowasm' },
      signal: AbortSignal.timeout(DOWNLOAD_TIMEOUT_MS),
```
src/cli/daemon.ts:148mcp-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.
```
    if (!isProcessRunning(pid)) break;
    try {
      const res = await fetch(healthUrl, { signal: AbortSignal.timeout(1000) });
      if (res.ok) {
        healthy = true;
```
src/connections/graphql.ts:76mcp-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 signal = signals.length === 1 ? signals[0] : AbortSignal.any(signals);

    const response = await fetch(this.options.baseUrl, {
      method: 'POST',
      headers: this.buildHeaders(),
```
src/connections/graphql.ts:121mcp-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 healthCheck(): Promise<boolean> {
    try {
      const response = await fetch(this.options.baseUrl, { method: 'POST', signal: AbortSignal.timeout(5000) });
      return response.ok || response.status === 400;
    } catch {
```
src/connections/rest.ts:70mcp-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 signal = signals.length > 0 ? (signals.length === 1 ? signals[0] : AbortSignal.any(signals)) : undefined;

    const response = await fetch(url, {
      method: 'GET',
      headers,
```
src/connections/rest.ts:110mcp-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 signal = signals.length > 0 ? (signals.length === 1 ? signals[0] : AbortSignal.any(signals)) : undefined;

    const response = await fetch(url, {
      method: 'POST',
      headers,
```
src/connections/rest.ts:145mcp-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 healthCheck(): Promise<boolean> {
    try {
      await fetch(this.options.baseUrl, { method: 'HEAD', signal: AbortSignal.timeout(5000) });
      return true;
    } catch {
```

src/entities/gene.ts:428mcp-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.

    // json()/text() parsing cannot handle it.
    const url = `https://www.proteinatlas.org/api/search_download.php?search=${encodeURIComponent(geneSymbol)}&format=json&columns=g,scl`;
    const rawResponse = await fetch(url, { signal });
    if (!rawResponse.ok) {
      throw new Error(`HTTP ${rawResponse.status}: ${rawResponse.statusText}`);

src/entities/geo.ts:405mcp-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 httpsUrl = url.replace(/^ftp:\/\//i, 'https://');
  assertDownloadableUrl(httpsUrl);
  const response = await fetch(httpsUrl, { signal: AbortSignal.timeout(DOWNLOAD_TIMEOUT_MS) });
  if (!response.ok) {
    throw new Error(`Failed to download ${httpsUrl}: HTTP ${response.status} ${response.statusText}`);

src/entities/patent/detail/wayback.ts:64mcp-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.
```
): Promise<string | null> {
  const { data, error } = await fetchWithTimeout(async (signal) => {
    const resp = await fetch(idUrl, {
      headers: { 'User-Agent': 'biomcp-patent/1.0' },
      signal,
```

src/wasmcore/assets.ts:140mcp-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 timeoutMs = this.cfg.downloadTimeoutMs ?? DEFAULT_DOWNLOAD_TIMEOUT_MS;
    try {
      const res = await fetch(url, {
        headers: { Accept: 'application/vnd.github+json', 'User-Agent': this.cfg.userAgent },
        signal: AbortSignal.timeout(timeoutMs),

src/wasmcore/assets.ts:161mcp-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 timeoutMs = this.cfg.assetTimeoutMs ?? DEFAULT_ASSET_TIMEOUT_MS;
    try {
      const res = await fetch(url, {
        headers: { 'User-Agent': this.cfg.userAgent },
        signal: AbortSignal.timeout(timeoutMs),
```
src/__tests__/biowasm/engine.test.ts:171mcp-js-prototype-pollution-merge-loop (medium/medium)
Test code — listed, not deducted: `03` §3 grades the code a user runs. 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.
```
  beforeEach(() => {
    for (const k of ENV_KEYS) {
      SAVED_ENV[k] = process.env[k];
      delete process.env[k];
    }
```
src/__tests__/biowasm/engine.test.ts:194mcp-js-prototype-pollution-merge-loop (medium/medium)
Test code — listed, not deducted: `03` §3 grades the code a user runs. 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 ENV_KEYS) {
      if (SAVED_ENV[k] === undefined) delete process.env[k];
      else process.env[k] = SAVED_ENV[k]!;
    }
  });
```
src/__tests__/biowasm/registry.test.ts:87mcp-js-prototype-pollution-merge-loop (medium/medium)
Test code — listed, not deducted: `03` §3 grades the code a user runs. 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.
```
  beforeEach(() => {
    for (const k of ENV_KEYS) {
      SAVED_ENV[k] = process.env[k];
      delete process.env[k];
    }
```
src/__tests__/biowasm/registry.test.ts:97mcp-js-prototype-pollution-merge-loop (medium/medium)
Test code — listed, not deducted: `03` §3 grades the code a user runs. 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 ENV_KEYS) {
      if (SAVED_ENV[k] === undefined) delete process.env[k];
      else process.env[k] = SAVED_ENV[k]!;
    }
    rmSync(cacheRoot, { recursive: true, force: true });
```
src/__tests__/cli/doctor.test.ts:21mcp-js-prototype-pollution-merge-loop (medium/medium)
Test code — listed, not deducted: `03` §3 grades the code a user runs. 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.
```
  dir = mkdtempSync(join(tmpdir(), 'biomcp-cli-doctor-'));
  for (const v of TRACKED_VARS) {
    SAVED_ENV[v] = process.env[v];
    delete process.env[v];
  }
```
src/__tests__/cli/doctor.test.ts:31mcp-js-prototype-pollution-merge-loop (medium/medium)
Test code — listed, not deducted: `03` §3 grades the code a user runs. 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 v of TRACKED_VARS) {
    if (SAVED_ENV[v] === undefined) delete process.env[v];
    else process.env[v] = SAVED_ENV[v];
  }
  resetLoaderStateForTests();
```
src/__tests__/config/handler.test.ts:33mcp-js-prototype-pollution-merge-loop (medium/medium)
Test code — listed, not deducted: `03` §3 grades the code a user runs. 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.
```
  dir = mkdtempSync(join(tmpdir(), 'biomcp-config-handler-'));
  for (const v of TRACKED_VARS) {
    SAVED_ENV[v] = process.env[v];
    delete process.env[v];
  }
```
src/__tests__/config/handler.test.ts:43mcp-js-prototype-pollution-merge-loop (medium/medium)
Test code — listed, not deducted: `03` §3 grades the code a user runs. 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 v of TRACKED_VARS) {
    if (SAVED_ENV[v] === undefined) delete process.env[v];
    else process.env[v] = SAVED_ENV[v];
  }
  resetLoaderStateForTests();
```
src/__tests__/connections/proxy.test.ts:43mcp-js-prototype-pollution-merge-loop (medium/medium)
Test code — listed, not deducted: `03` §3 grades the code a user runs. 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.
```
    savedEnv = {};
    for (const key of PROXY_ENV_KEYS) {
      savedEnv[key] = process.env[key];
      delete process.env[key];
    }
```
src/__tests__/connections/proxy.test.ts:55mcp-js-prototype-pollution-merge-loop (medium/medium)
Test code — listed, not deducted: `03` §3 grades the code a user runs. 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 PROXY_ENV_KEYS) {
      if (savedEnv[key] === undefined) delete process.env[key];
      else process.env[key] = savedEnv[key]!;
    }
    consoleErrorSpy.mockRestore();
```
src/__tests__/entities/geo.test.ts:209mcp-js-prototype-pollution-merge-loop (medium/medium)
Test code — listed, not deducted: `03` §3 grades the code a user runs. 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(entries)) {
          const base = entries[key];
          entries[key] = () => ({ ...base(), extrelations: overrides.extrelations });
        }
      }
```
src/__tests__/entities/geo.test.ts:215mcp-js-prototype-pollution-merge-loop (medium/medium)
Test code — listed, not deducted: `03` §3 grades the code a user runs. 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(entries)) {
          const base = entries[key];
          entries[key] = () => {
            const entry = base();
            return { ...entry, pubmedids: (entry as { pubmedids?: unknown }).pubmedids?.map(String) };
```
src/__tests__/entities/geo.test.ts:225mcp-js-prototype-pollution-merge-loop (medium/medium)
Test code — listed, not deducted: `03` §3 grades the code a user runs. 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 id of ids) {
        const factory = entries[id];
        if (factory) result[id] = factory();
      }
      return { result };
```
src/__tests__/ranalysis/engine.test.ts:49mcp-js-prototype-pollution-merge-loop (medium/medium)
Test code — listed, not deducted: `03` §3 grades the code a user runs. 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.
```
  beforeEach(() => {
    for (const k of ENV_KEYS) {
      SAVED_ENV[k] = process.env[k];
      delete process.env[k];
    }
```
src/__tests__/ranalysis/engine.test.ts:75mcp-js-prototype-pollution-merge-loop (medium/medium)
Test code — listed, not deducted: `03` §3 grades the code a user runs. 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 ENV_KEYS) {
      if (SAVED_ENV[k] === undefined) delete process.env[k];
      else process.env[k] = SAVED_ENV[k]!;
    }
  });
```
src/__tests__/ranalysis/mirror.test.ts:107mcp-js-prototype-pollution-merge-loop (medium/medium)
Test code — listed, not deducted: `03` §3 grades the code a user runs. 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.
```
  beforeEach(() => {
    for (const k of ENV_KEYS) {
      SAVED_ENV[k] = process.env[k];
      delete process.env[k];
    }
```
src/__tests__/ranalysis/mirror.test.ts:123mcp-js-prototype-pollution-merge-loop (medium/medium)
Test code — listed, not deducted: `03` §3 grades the code a user runs. 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 ENV_KEYS) {
      if (SAVED_ENV[k] === undefined) delete process.env[k];
      else process.env[k] = SAVED_ENV[k]!;
    }
    rmSync(tmpRoot, { recursive: true, force: true });
```
src/__tests__/server/geo-tools.test.ts:109mcp-js-prototype-pollution-merge-loop (medium/medium)
Test code — listed, not deducted: `03` §3 grades the code a user runs. 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 result: Record<string, unknown> = { uids: ids };
      for (const id of ids) {
        if (id === '200183947') result[id] = gseEsummaryEntry();
      }
      return { result };
```
src/__tests__/wasmcore/assets.test.ts:62mcp-js-prototype-pollution-merge-loop (medium/medium)
Test code — listed, not deducted: `03` §3 grades the code a user runs. 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.
```
  beforeEach(() => {
    for (const k of ENV_KEYS) {
      SAVED_ENV[k] = process.env[k];
      delete process.env[k];
    }
```
src/__tests__/wasmcore/assets.test.ts:77mcp-js-prototype-pollution-merge-loop (medium/medium)
Test code — listed, not deducted: `03` §3 grades the code a user runs. 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 ENV_KEYS) {
      if (SAVED_ENV[k] === undefined) delete process.env[k];
      else process.env[k] = SAVED_ENV[k];
    }
    rmSync(tmpRoot, { recursive: true, force: true });
```
src/__tests__/ranalysis/mirror.test.ts:57mcp-js-ssrf-nonliteral-url (medium/low)
Test code — listed, not deducted: `03` §3 grades the code a user runs. 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.
```
  function get(path: string): Promise<{ status: number; body: string }> {
    return fetch(base + path).then(async (r) => ({ status: r.status, body: await r.text() }));
  }
```
src/__tests__/ranalysis/mirror.test.ts:64mcp-js-ssrf-nonliteral-url (medium/low)
Test code — listed, not deducted: `03` §3 grades the code a user runs. 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.
```
    expect(r.status).toBe(200);
    expect(r.body).toBe('wasm-bytes');
    const res = await fetch(base + '/bin/sub/pkg_1.0.0.tgz?x=1');
    expect(res.status).toBe(200);
  });
```
src/__tests__/wasmcore/assets.test.ts:245mcp-js-ssrf-nonliteral-url (medium/low)
Test code — listed, not deducted: `03` §3 grades the code a user runs. 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.
```
  it('serves files with the configured MIME type and CORS', async () => {
    const res = await fetch(base + '/sub/a.wasm');
    expect(res.status).toBe(200);
    expect(res.headers.get('content-type')).toBe('application/wasm');
```
src/__tests__/wasmcore/assets.test.ts:253mcp-js-ssrf-nonliteral-url (medium/low)
Test code — listed, not deducted: `03` §3 grades the code a user runs. 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.
```
  it('falls back to text/plain for unmapped extensions', async () => {
    const res = await fetch(base + '/sub/notes.txt');
    expect(res.status).toBe(200);
    expect(res.headers.get('content-type')).toBe('text/plain');
```
src/__tests__/wasmcore/assets.test.ts:261mcp-js-ssrf-nonliteral-url (medium/low)
Test code — listed, not deducted: `03` §3 grades the code a user runs. 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.
```
    writeFileSync(join(tmpRoot, 'outside.txt'), 'secret');
    for (const path of ['/nosuch.bin', '/outside.txt', '/', '//sub/a.wasm']) {
      const res = await fetch(base + path);
      expect([path, res.status]).toEqual([path, 404]);
    }
```
src/__tests__/wasmcore/assets.test.ts:270mcp-js-ssrf-nonliteral-url (medium/low)
Test code — listed, not deducted: `03` §3 grades the code a user runs. 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.
```
    expect(again).toBe(base);
    await server.close();
    await expect(fetch(base + '/manifest.json')).rejects.toThrow();
  });
});
```

Auth Posture

authentication_model
stdio transport: the client launches the server as a subprocess, so the OS process boundary is the auth boundary — `03` §4 does not penalise absent auth here
transport_security
declared transport: stdio — launched as a subprocess by the client, so the security boundary is the client process, not a network port (`03` §4)
secret_handling
detect-secrets matched 39 credential-shaped string(s), every one from a keyword or entropy heuristic (Base64 High Entropy String, Hex High Entropy String). 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 dist/biowasm.js:2; Hex High Entropy String at dist/biowasm.js:2; Hex High Entropy String at dist/biowasm.js:2; Hex High Entropy String at dist/biowasm.js:2; Hex High Entropy String at dist/biowasm.js:2; Hex High Entropy String at dist/biowasm.js:2; Hex High Entropy String at dist/biowasm.js:2; Hex High Entropy String at dist/biowasm.js:2; Hex High Entropy String at dist/biowasm.js:2; Hex High Entropy String at dist/bundle.js:129; …and 29 more matches
authorization_granularity
source was fetched but every file in it was oversized, unreadable or excluded, so no source text could be read, so neither the tool count nor any access-control logic can be read

Maintenance

recency
last commit 1 day(s) before 2026-10-16
issue_responsiveness
lifetime median (1 issue(s) in the last 6 months, under `03` §5's floor of 3): 0.4 day(s) to first maintainer comment
release_cadence
released 1 day(s) ago (by releases), inside `03` §5's 30-day window
bus_factor
2 regular authors in the last 12 months
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 'Apache-2.0' from its text
readme_quality
README.md: installation instructions (+25), configuration documented (+25), exposed tools or resources enumerated (+30), states what the server does in the first 200 words (+20)
declared_scopes
specific scope or access documentation is present, but `03` §7's 100 and 60 bands both compare it against scopes INFERRED from static analysis, which is not built yet. Scoring 100 on an empty inference would be a vacuous truth — 'all ∅ inferred scopes are documented'.
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
no SECURITY.md and no disclosure contact in the README, so a finder has no route to report a vulnerability privately

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