github · codebase-memory-mcpHEAD

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.

# Usage:

#   docker compose -f test-infrastructure/docker-compose.yml run --rm build-windows

#   docker compose -f test-infrastructure/docker-compose.yml run --rm test-windows

FROM mstorsjo/llvm-mingw:latest

# Install Wine + binfmt support for transparent .exe execution

RUN dpkg --add-architecture i386 && \

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.

print(f"Server output was:\n{output!r}")

        sys.exit(1)

    if "tools" not in output:

        print("FAIL: tools/list response body missing 'tools' key")

        print(f"Server output was:\n{output!r}")

        sys.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).

setLoading(true);

    try {

      const q = path ? `?path=${encodeURIComponent(path)}` : "";

      const res = await fetch(`/api/browse${q}`);

      const data = await res.json();

      if (data.error) throw new Error(data.error);

      setCurrentPath(data.path ?? "");

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).

# --- Download binary ---

fetch() {

    local url="$1" tool="$2"

    if [ "$tool" = "curl" ]; then

        curl -fsSL "$url"

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).

useEffect(() => {

    const poll = setInterval(async () => {

      try {

        const res = await fetch("/api/logs?lines=200");

        const data = await res.json();

        setLines(data.lines ?? []);

      } catch { /* ignore */ }

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).

if (!currentPath) return;

    setSubmitting(true); setError(null);

    try {

      const res = await fetch("/api/index", { method: "POST", headers: { "Content-Type": "application/json" }, body: JSON.stringify({ root_path: currentPath }) });

      const data = await res.json();

      if (!res.ok) throw new Error(data.error ?? "Failed");

      onCreated(); onClose();

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).

const [info, setInfo] = useState("");

  useEffect(() => {

    fetch(`/api/project-health?name=${encodeURIComponent(name)}`)

      .then((r) => r.json())

      .then((d) => {

        setStatus(d.status ?? "corrupt");

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).

const fetchProcesses = useCallback(async () => {

    try {

      const res = await fetch("/api/processes");

      const data = await res.json();

      setProcesses(data.processes ?? []);

      setSelfMetrics({

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).

} catch { /* ignore */ }

    }, 2000);

    /* Initial fetch */

    fetch("/api/logs?lines=200").then(r => r.json()).then(d => setLines(d.lines ?? [])).catch(() => {});

    return () => clearInterval(poll);

  }, []);

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).

}

function fetchData(url) {

    return fetch(url).then(r => r.json());

}

module.exports = { render, fetchData };

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).

maxNodes = 50000,

): Promise<GraphData> {

  const params = new URLSearchParams({ project, max_nodes: String(maxNodes) });

  const res = await fetch(`/api/layout?${params}`);

  if (!res.ok) {

    const body = await res.json().catch(() => ({ error: res.statusText }));

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).

useEffect(() => {

    const poll = setInterval(async () => {

      try {

        const data = await (await fetch("/api/index-status")).json();

        setJobs(data);

        if (data.length > 0 && data.every((j: { status: string }) => j.status !== "indexing")) onDone();

      } catch { /* */ }

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).

const deleteProject = useCallback(async (name: string) => {

    if (!confirm(`Delete index for "${name}"?`)) return;

    try { await fetch(`/api/project?name=${encodeURIComponent(name)}`, { method: "DELETE" }); refresh(); } catch { /* */ }

  }, [refresh]);

  return (

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).

const fetchAdr = useCallback(async () => {

    try {

      const res = await fetch(`/api/adr?project=${encodeURIComponent(project)}`);

      const data = await res.json();

      setHasAdr(data.has_adr ?? false);

      if (data.content) setContent(data.content);

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).

return nil

}

// validateURLScheme rejects non-https URLs before any fetch (defense-in-depth).

func validateURLScheme(rawURL string) error {

	if !strings.HasPrefix(rawURL, "https://") {

		return fmt.Errorf("refusing non-https URL: %s", rawURL)

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).

const [data, setData] = useState(null);

    const [loading, setLoading] = useState(true);

    useEffect(() => {

        fetch('/api/data/${i}/' + id)

            .then(r => r.json())

            .then(d => { setData(d); setLoading(false); });

    }, [id]);

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).

os.execv(str(bin_path), args)  # noqa: S606 — list form, no shell

    else:

        import subprocess

        result = subprocess.run(args)  # noqa: S603 — list form, no shell=True

        sys.exit(result.returncode)

Package declares an install-time hook (npm postinstall/preinstall/prepare, setup.py cmdclass override, custom setuptools install class, or non-default pyproject build-backend). Anyone installing this package runs the hook. Confirm the hook is necessary and review its contents; prefer shipping a plain library without install-time execution.

"codebase-memory-mcp": "./bin.js"

  },

  "scripts": {

    "postinstall": "node install.js"

  },

  "engines": {

    "node": ">=18"

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.

# Mirrors the Alpine CI environment for portable (musl static) builds.

#   - Alpine 3.21 with musl libc

#   - GCC + static zlib for fully static binaries

#   - Produces portable Linux binaries that run on any distro

#

# Build:  docker build -f test-infrastructure/Dockerfile.alpine -t cbm-alpine test-infrastructure/

# Run:    docker run --rm -v $(pwd):/src cbm-alpine

FROM alpine:3.21@sha256:a8560b36e8b8210634f77d9f7f9efd7ffa463e380b75e2e74aff4511df3ef88c

RUN apk add --no-cache \

    build-base 

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.

# Mirrors the Ubuntu CI environment exactly:

#   - Ubuntu 24.04 (same as GitHub Actions ubuntu-latest / ubuntu-24.04-arm)

#   - GCC (system default) with ASan + UBSan + LeakSanitizer

#   - libsqlite3-dev + zlib1g-dev (same as CI "Install deps" step)

#

# Build:  docker build -t cbm-test test-infrastructure/

# Run:    docker run --rm -v $(pwd):/src cbm-test

FROM ubuntu:noble

# Minimal: gcc + zlib only. sqlite3 is vendored (compiled from source with ASan).

RUN apt-get update && apt-get install -y

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.

# Lint environment — mirrors CI lint job exactly:

#   - clang-format-20 (from LLVM apt repo)

#   - cppcheck 2.20.0 (built from source, same as CI)

#

# Build:  docker build -t cbm-lint -f test-infrastructure/Dockerfile.lint test-infrastructure/

# Run:    docker run --rm -v $(pwd):/src cbm-lint

FROM ubuntu:noble

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

    gcc g++ make cmake \

    libsqlite3-dev zlib1g-dev \

    pkg-config wget gnupg git ca-certificates \

    && rm -rf 

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.

# Cross-compile AND run Windows tests locally using llvm-mingw + Wine.

#

# llvm-mingw: LLVM/Clang-based MinGW toolchain

# Wine: runs the resulting .exe for actual test execution

#

# Usage:

#   docker compose -f test-infrastructure/docker-compose.yml run --rm build-windows

#   docker compose -f test-infrastructure/docker-compose.yml run --rm test-windows

FROM mstorsjo/llvm-mingw:latest

# Install Wine + binfmt support for transparent .exe execution

RUN dpkg --add-architecture i386 && \

    apt-g

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.

json_lines = []

    for ln in lines:

        try:

            json_lines.append(_json.loads(ln))

        except _json.JSONDecodeError:

            pass

    ids = {obj.get("id") for obj in json_lines if "id" in obj}

    if 1 not in ids:

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.

pass  # Non-fatal: checksum unavailable

    finally:

        try:

            os.unlink(tmp_path)

        except Exception:

            pass

def _version() -> str:

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 {

                *this = other;

            }

            catch (const Error&) {} // NOLINT(bugprone-empty-catch)

        }

        ~Macro() {

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.

print("codebase-memory-mcp: checksum verified.", file=sys.stderr)

                    break

    except SystemExit:

        raise

    except Exception:

        pass  # Non-fatal: checksum unavailable

    finally:

        try:

            os.unlink(tmp_path)