Skip to content

com.dmzagent/skill-builder-mcp

version 1.0.1

scanned 2026-10-16
source github.com/praeceptor-thesis/skill-builder-landing
commit 736aa306da9d
transport stdio
files read 43
methodology 0.2.0
ruleset 0.1.1

Code Safetyweight 30

45

scored on the declared repository at version 1.0.1, because the published package carries its code only as build output, which is not read as the server's own source

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

93measured on 45% of this axis

Transparencyweight 15

33

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/cli/src/index.ts:24mcp-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.
```
function openInBrowser(url: string): void {
  const cmd = process.platform === 'darwin' ? 'open' : process.platform === 'win32' ? 'start' : 'xdg-open';
  execSync(`${cmd} "${url}"`);
}
```
packages/cli/src/index.ts:24mcp-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.
```
function openInBrowser(url: string): void {
  const cmd = process.platform === 'darwin' ? 'open' : process.platform === 'win32' ? 'start' : 'xdg-open';
  execSync(`${cmd} "${url}"`);
}
```
packages/cli/src/anthropic.ts:109mcp-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<Partial<SkillSpec>> {
  const url = `${cfg.baseUrl || 'https://api.anthropic.com'}/v1/messages`;
  const res = await fetch(url, {
    method: 'POST',
    headers: {
```
packages/cli/src/api/client.ts:201mcp-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 response = await fetch(url, {
      headers: { ...headers, ...options?.headers },
      ...options,
```
packages/mcp/src/registry-client.ts:60mcp-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 response: Response;
    try {
      response = await fetch(url, {
        ...options,
        headers: { ...headers, ...(options.headers as Record<string, string>) },
```
packages/shared/src/api.ts:72mcp-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 response = await fetch(joinUrl(baseUrl, path), {
      ...options,
      headers,
```
packages/shared/src/api.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.
```
    listSkills: (params?: RegistrySearchParams) => {
      const query = toSearchParams(params);
      return request<SkillListResponse>(`/skills${query ? `?${query}` : ''}`, {
        signal: params?.signal,
      });
```
packages/shared/src/api.ts:88mcp-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.
```
    },

    getSkill: (id: string) => request<SkillResponse>(`/skills/${encodeURIComponent(id)}`),

    saveSkill: (skill: SkillPayload) =>
```
packages/shared/src/api.ts:91mcp-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.
```
    saveSkill: (skill: SkillPayload) =>
      request<SaveSkillResponse>('/skills', {
        method: 'POST',
        body: JSON.stringify(skill),
```
packages/shared/src/api.ts:97mcp-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.
```
    updateSkill: (id: string, skill: Partial<SkillPayload>) =>
      request<SkillResponse>(`/skills/${encodeURIComponent(id)}`, {
        method: 'PATCH',
        body: JSON.stringify(skill),
```
packages/shared/src/api.ts: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.
```
    forkSkill: (id: string, body?: { name?: string }) =>
      request<ForkSkillResponse>(`/skills/${encodeURIComponent(id)}/fork`, {
        method: 'POST',
        body: JSON.stringify(body || {}),
```
packages/shared/src/api.ts:109mcp-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.
```
    deleteSkill: (id: string) =>
      request<{ success: boolean }>(`/skills/${encodeURIComponent(id)}`, {
        method: 'DELETE',
      }),
```
packages/shared/src/api.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.
```
    createSkillBuilderSession: (payload: CreateSkillBuilderSessionRequest = {}) =>
      request<CreateSkillBuilderSessionResponse>('/skill-builder/session', {
        method: 'POST',
        body: JSON.stringify(payload),
```

packages/shared/src/api.ts:120mcp-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.


    getSkillBuilderSession: (sessionId: string) =>
      request<{ session: SkillBuilderSession }>(`/skill-builder/session/${encodeURIComponent(sessionId)}`),

    sendSkillBuilderTurn: (sessionId: string, payload: SkillBuilderTurnRequest) =>

packages/shared/src/api.ts:123mcp-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.


    sendSkillBuilderTurn: (sessionId: string, payload: SkillBuilderTurnRequest) =>
      request<SkillBuilderTurnResponse>(`/skill-builder/session/${encodeURIComponent(sessionId)}`, {
        method: 'POST',
        body: JSON.stringify(payload),

packages/shared/src/api.ts:129mcp-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.
```
    executeSkill: (id: string, payload: ExecuteSkillRequest) =>
      request<ExecuteSkillResponse>(`/skills/${encodeURIComponent(id)}/execute`, {
        method: 'POST',
        body: JSON.stringify(payload),
```
packages/shared/src/api.ts:135mcp-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.
```
    login: (email: string, password: string) =>
      request<AuthResponse>('/auth/login', {
        method: 'POST',
        body: JSON.stringify({ email, password }),
```
packages/shared/src/api.ts:141mcp-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.
```
    register: (name: string, email: string, password: string, handle: string) =>
      request<AuthResponse>('/auth/register', {
        method: 'POST',
        body: JSON.stringify({ name, email, password, handle }),
```
packages/shared/src/api.ts:146mcp-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.
```
      }),

    getCurrentUser: () => request<{ user: User }>('/auth/me'),
  };
}
```

packages/web/src/services/api.ts:286mcp-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 fetchJson<T>(url: string, options?: RequestInit): Promise<T> {
  const { headers: extraHeaders, ...rest } = options ?? {};
  const response = await fetch(url, {
    ...rest,
    headers: { 'Content-Type': 'application/json', ...extraHeaders },

scripts/migrate-zone.mjs: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.

      if (body) headers['content-type'] = 'application/json';
      if (token) headers.authorization = `Bearer ${token}`;
      const res = await fetch(url, { method, headers, body: body ? JSON.stringify(body) : undefined, signal: ctrl.signal });
      const text = await res.text();
      let json;

scripts/skill-digest.mjs:106mcp-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 t = setTimeout(() => ctrl.abort(), timeoutMs);
    try {
      const res = await fetch(url, { signal: ctrl.signal, headers: { accept: 'application/json' } });
      clearTimeout(t);
      if (!res.ok) { lastErr = new Error(`HTTP ${res.status}`); continue; }

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 11 day(s) before 2026-10-16
issue_responsiveness
this repository has no issues `03` §5's window covers. An unanswered issue scores 0 under §5, but a repository with no issues filed has not failed to answer one.
release_cadence
a release exists but fewer than two fall inside `03` §5's 12-month window, so no median gap can be taken — and §5's remaining bands are all defined on that median. A limit of the methodology, not of this repository.
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
package.json declares 'MIT' but no LICENSE file ships with the source
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
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
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