github · docs-mcp-serverHEAD

Container base image uses the floating :latest tag. This provides no reproducibility — the image content can change under you, and there is no signature to verify.

### Single Container

```dockerfile

FROM ghcr.io/arabold/docs-mcp-server:latest

EXPOSE 6280

CMD ["--protocol", "http", "--port", "6280"]

```

Dockerfile never sets a non-root `USER` directive, so the CMD runs as root by default. Any RCE or library-level vulnerability exploited inside this container gets full privileges (MCP Top-10 R3). Add `USER <non-root>` before CMD / ENTRYPOINT in the final stage — e.g. `USER 1000`, `USER nobody`, or `USER nonroot` on distroless.

# Base stage with build dependencies

FROM node:22-slim AS base

WORKDIR /app

# Install build dependencies for native modules (better-sqlite3, tree-sitter, etc.)

RUN apt-get update \

  && apt-get install -y --no-install-recommends \

  python3 \

  make \

  g++ \

  && rm -rf /var/lib/apt/lists/*

# Build stage

FROM base AS builder

# Accept build argument for PostHog API key

ARG POSTHOG_API_KEY

ENV POSTHOG_API_KEY=$POSTHOG_API_KEY

# Copy package files

COPY package*.json ./

# Install all dependen

User-controlled value printed to terminal without ANSI escape sanitization. Malicious input can inject cursor-control sequences, rewrite earlier output, or hide shell commands from the operator.

// Subscribe to events and dispatch them as DOM events for HTMX

eventClient.subscribe((event) => {

  console.log(`📋 Received event: ${event.type}`, event.payload);

  // Dispatch custom event with payload that HTMX can listen to

  document.body.dispatchEvent(

    new CustomEvent(event.type, {

User-controlled value printed to terminal without ANSI escape sanitization. Malicious input can inject cursor-control sequences, rewrite earlier output, or hide shell commands from the operator.

// Listen for all event types defined in ServerEventName

    const eventTypes = Object.values(ServerEventName) as SseEventName[];

    console.log("🔧 Setting up event listeners", eventTypes);

    for (const eventType of eventTypes) {

      this.eventSource.addEventListener(eventType, (event: MessageEvent) => {

User-controlled value printed to terminal without ANSI escape sanitization. Malicious input can inject cursor-control sequences, rewrite earlier output, or hide shell commands from the operator.

});

    this.eventSource.addEventListener("error", (event) => {

      console.error("❌ SSE connection error:", event);

      this.isConnected = false;

      // EventSource will automatically attempt to reconnect

    });

User-controlled value printed to terminal without ANSI escape sanitization. Malicious input can inject cursor-control sequences, rewrite earlier output, or hide shell commands from the operator.

// Add a generic message listener as a fallback to catch any events

    this.eventSource.addEventListener("message", (event: MessageEvent) => {

      console.log("📨 Generic message event received:", event.data);

    });

  }

User-controlled value printed to terminal without ANSI escape sanitization. Malicious input can inject cursor-control sequences, rewrite earlier output, or hide shell commands from the operator.

// 2. The rest is the query

  const query = args.join(" ").trim();

  // console.error(`DEBUG: Executing search for query: "${query}"`);

  // 3. Determine Library (Context -> Env -> Default)

  const library = context.vars?.library || process.env.LIBRARY || "react";

User-controlled value printed to terminal without ANSI escape sanitization. Malicious input can inject cursor-control sequences, rewrite earlier output, or hide shell commands from the operator.

try {

        callback(event);

      } catch (error) {

        console.error("Error in event callback:", error);

      }

    }

  }

User-controlled value printed to terminal without ANSI escape sanitization. Malicious input can inject cursor-control sequences, rewrite earlier output, or hide shell commands from the operator.

payload,

          });

        } catch (error) {

          console.error(`Failed to parse SSE event data: ${error}`);

        }

      });

    }

User-controlled value printed to terminal without ANSI escape sanitization. Malicious input can inject cursor-control sequences, rewrite earlier output, or hide shell commands from the operator.

const library = context.vars?.library || process.env.LIBRARY || "react";

  if (!query) {

    console.error("Error: No query provided");

    console.error("Args received:", process.argv);

    process.exit(1);

  }

Network / IO / subprocess call without an explicit timeout. A malicious or hung upstream (HTTP host, socket peer, child process) can pin threads, exhaust connection/process pools, and make the MCP server unresponsive. Always pass a bounded timeout. v2 extends v1 with subprocess coverage (R03 from the legacy readiness audit).

* Uses enhanced MIME type detection for better source code file recognition.

   * Supports conditional fetching via ETag comparison for efficient refresh operations.

   */

  async fetch(source: string, options?: FetchOptions): Promise<RawContent> {

    // Remove the file:// protocol prefix and handle both file:// and file:/// formats

    let filePath = source.replace(/^file:\/\/\/?/, "");

Network / IO / subprocess call without an explicit timeout. A malicious or hung upstream (HTTP host, socket peer, child process) can pin threads, exhaust connection/process pools, and make the MCP server unresponsive. Always pass a bounded timeout. v2 extends v1 with subprocess coverage (R03 from the legacy readiness audit).

[filePath]: "initial",

      });

      const result1 = await fetcher.fetch(`file://${filePath}`);

      const oldEtag = result1.etag;

      // Wait and modify file

Network / IO / subprocess call without an explicit timeout. A malicious or hung upstream (HTTP host, socket peer, child process) can pin threads, exhaust connection/process pools, and make the MCP server unresponsive. Always pass a bounded timeout. v2 extends v1 with subprocess coverage (R03 from the legacy readiness audit).

let repoContent: Awaited<ReturnType<typeof this.httpFetcher.fetch>>;

      try {

        repoContent = await this.httpFetcher.fetch(repoUrl, { signal, headers });

      } catch (error) {

        // Convert HTTP auth errors to user-friendly messages

        if (error instanceof ScraperError) {

Network / IO / subprocess call without an explicit timeout. A malicious or hung upstream (HTTP host, socket peer, child process) can pin threads, exhaust connection/process pools, and make the MCP server unresponsive. Always pass a bounded timeout. v2 extends v1 with subprocess coverage (R03 from the legacy readiness audit).

};

      // Use AutoDetectFetcher which handles fallbacks automatically

      const rawContent: RawContent = await this.fetcher.fetch(url, fetchOptions);

      const effectiveSource = options.preserveHashes

        ? this.restorePreservedHash(url, rawContent.source)

        : rawContent.source;

Network / IO / subprocess call without an explicit timeout. A malicious or hung upstream (HTTP host, socket peer, child process) can pin threads, exhaust connection/process pools, and make the MCP server unresponsive. Always pass a bounded timeout. v2 extends v1 with subprocess coverage (R03 from the legacy readiness audit).

};

      mockedAxios.get.mockResolvedValue(mockResponse);

      await fetcher.fetch("https://example.com");

      expect(mockedAxios.get).toHaveBeenCalledWith(

        "https://example.com",

Silent error swallowing detected. An except clause that does pass or ... discards the exception with no log, no metric, and no trace. This blinds incident response and hides real failures.

try {

      const u = new URL(url);

      basename = u.pathname ? u.pathname.split("/").pop() : undefined;

    } catch {}

  }

  // Helper to strip leading slash from patterns for basename matching

  const stripSlash = (patterns?: string[]) =>