io.github.MohamedAbdallah-14/prompt-to-asset

version 0.4.2

scanned 2026-10-16
source github.com/MohamedAbdallah-14/prompt-to-asset
commit 7f5676a8fe4f
transport stdio
files read 113
methodology 0.2.0
ruleset 0.1.1

Code Safetyweight 30

78measured on 98% of this axis

scored on the declared repository at version 0.4.2, because the published package carries its code only as build output, which is not read as the server's own source; 6 findings in test code are listed but not deducted; 1 file could not be parsed and was 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

57measured on 90% 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

packages/mcp-server/src/pipeline/matte.ts:67mcp-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 (rmbgUrl && (mode === "auto" || mode === "rmbg" || mode === "birefnet")) {
    try {
      const resp = await fetch(rmbgUrl, {
        method: "POST",
        headers: { "Content-Type": "application/octet-stream" },
```
packages/mcp-server/src/pipeline/upscale.ts:46mcp-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 (upscalerUrl && mode !== "lanczos") {
    try {
      const resp = await fetch(upscalerUrl, {
        method: "POST",
        headers: {
```
packages/mcp-server/src/pipeline/validate.ts:725mcp-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 (!url) return { ran: false };
  try {
    const resp = await fetch(url, {
      method: "POST",
      headers: { "Content-Type": "application/json" },
```
packages/mcp-server/src/pipeline/validate.ts:790mcp-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 (!url) return { ran: false };
  try {
    const resp = await fetch(url, {
      method: "POST",
      headers: { "Content-Type": "application/json" },
```
packages/mcp-server/src/pipeline/vectorize.ts:57mcp-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 ((mode === "recraft" || mode === "auto") && recraftUrl) {
    try {
      const resp = await fetch(recraftUrl, {
        method: "POST",
        headers: { "Content-Type": "application/octet-stream" },
```
packages/mcp-server/src/providers/bfl.ts:61mcp-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 endpoint = bflEndpoint(modelId);
    const resp = await fetch(endpoint, {
      method: "POST",
      headers: {
```

packages/mcp-server/src/providers/bfl.ts:83mcp-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 i = 0; i < 60; i++) {
      await new Promise((r) => setTimeout(r, 1500));
      const p = await fetch(pollUrl, { headers: { "x-key": CONFIG.apiKeys.flux } });
      const pj = (await p.json()) as { status?: string; result?: { sample?: string } };
      if (pj.status === "Ready" && pj.result?.sample) {

packages/mcp-server/src/providers/bfl.ts:95mcp-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 (!imageUrl) throw new ProviderError("bfl", modelId, "timed out waiting for result");

    const imgResp = await fetch(imageUrl);
    const image = Buffer.from(await imgResp.arrayBuffer());
```
packages/mcp-server/src/providers/cloudflare.ts:82mcp-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.
```
    )}/ai/run/${cfModel}`;

    const resp = await fetch(url, {
      method: "POST",
      headers: {
```
packages/mcp-server/src/providers/comfyui.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.
```
    let resp: Response;
    try {
      resp = await fetch(url, {
        method: "POST",
        headers: {
```
packages/mcp-server/src/providers/fal.ts:57mcp-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 resp = await fetch(endpoint, {
      method: "POST",
      headers: {
```
packages/mcp-server/src/providers/fal.ts:75mcp-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 (!imageUrl) throw new ProviderError("fal", modelId, "no image URL in response");

    const imgResp = await fetch(imageUrl);
    const image = Buffer.from(await imgResp.arrayBuffer());
```
packages/mcp-server/src/providers/google.ts:86mcp-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 resp = await fetch(url, {
      method: "POST",
      headers: {
```
packages/mcp-server/src/providers/ideogram.ts:84mcp-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.
```
      throw new ProviderError("ideogram", modelId, "no image URL in response");
    }
    const imgResp = await fetch(imageUrl);
    const image = Buffer.from(await imgResp.arrayBuffer());
```
packages/mcp-server/src/providers/leonardo.ts:107mcp-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 (!imageUrl) throw new ProviderError("leonardo", modelId, "timed out waiting for result");

    const imgResp = await fetch(imageUrl);
    const image = Buffer.from(await imgResp.arrayBuffer());
    return {
```
packages/mcp-server/src/providers/pollinations.ts:84mcp-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 resp = await fetch(url.toString(), { headers });
    if (!resp.ok) {
      const errText = await resp.text().catch(() => "");
```
packages/mcp-server/src/providers/recraft.ts:78mcp-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.
```
      image = Buffer.from(first.b64_json, "base64");
    } else if (first?.url) {
      const r = await fetch(first.url);
      image = Buffer.from(await r.arrayBuffer());
    } else {
```
packages/mcp-server/src/providers/replicate.ts:81mcp-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 body = ref.version ? { version: ref.version, input } : { input };

    const createResp = await fetch(url, {
      method: "POST",
      headers: {
```
packages/mcp-server/src/providers/replicate.ts:114mcp-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 (!pollUrl) break;
      await new Promise((r) => setTimeout(r, 2000));
      const poll = await fetch(pollUrl, {
        headers: { Authorization: `Bearer ${CONFIG.apiKeys.replicate}` }
      });
```
packages/mcp-server/src/providers/replicate.ts:134mcp-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 imgResp = await fetch(imgUrl);
    const image = Buffer.from(await imgResp.arrayBuffer());
    return {
```
packages/mcp-server/src/providers/stability.ts:54mcp-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 (modelId === "sd3-large") form.set("model", "sd3-large");

    const resp = await fetch(endpoint, {
      method: "POST",
      headers: {
```
packages/mcp-server/src/providers/stable-horde.ts:118mcp-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.
```
      image = Buffer.from(b64, "base64");
    } else {
      const imgResp = await fetch(imageUrl);
      image = Buffer.from(await imgResp.arrayBuffer());
    }
```
packages/mcp-server/src/tools/train-brand-lora.ts:87mcp-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 resp: Response;
  try {
    resp = await fetch(url, {
      method: "POST",
      headers: {
```
packages/mcp-server/src/modes.test.ts:114mcp-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.
```
  afterEach(() => {
    for (const k of KEYS) {
      if (snapshot[k] !== undefined) process.env[k] = snapshot[k];
      else delete process.env[k];
    }
```
packages/mcp-server/src/tools/capabilities.test.ts:34mcp-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.
```
  afterEach(() => {
    for (const k of KEYS) {
      if (snapshot[k] !== undefined) process.env[k] = snapshot[k];
      else delete process.env[k];
    }
```
packages/mcp-server/src/tools/doctor.test.ts:34mcp-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.
```
  afterEach(() => {
    for (const k of KEYS) {
      if (snapshot[k] !== undefined) process.env[k] = snapshot[k];
      else delete process.env[k];
    }
```
packages/mcp-server/src/tools/enhance-prompt.test.ts:24mcp-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.
```
  afterEach(() => {
    for (const k of KEYS) {
      if (snapshot[k] !== undefined) process.env[k] = snapshot[k];
      else delete process.env[k];
    }
```
packages/mcp-server/src/tools/models.test.ts:16mcp-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.
```
  afterEach(() => {
    for (const k of KEYS) {
      if (snapshot[k] !== undefined) process.env[k] = snapshot[k];
      else delete process.env[k];
    }
```
packages/mcp-server/src/tools/soft-fallback.test.ts:23mcp-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 keysToSnapshot) {
      if (envBackup[k] === undefined) delete process.env[k];
      else process.env[k] = envBackup[k];
    }
  });
```

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
source was fetched but every file in it was oversized, unreadable or excluded, so no source text could be read, so there is nothing to scan for committed credentials
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 87 day(s) before 2026-10-16
issue_responsiveness
median over 3 issue(s) in the last 6 months: 152.5 day(s) to first maintainer comment
release_cadence
median release gap 0 days (by releases), last release 173 day(s) ago
bus_factor
sole maintainer
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: installation instructions (+25), configuration documented (+25), exposed tools or resources enumerated (+30)
declared_scopes
neither the README nor the MCP manifest documents what the server accesses or what side effects it has
changelog
CHANGELOG.md present
security_contact
no SECURITY.md, but README.md documents a disclosure route — `03` §7 accepts either

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