Mostly safe — a couple of notes worth reading.
Scanned 5/3/2026, 7:03:43 PM·Cached result·Fast Scan·45 rules·How we decide ↗
AIVSS Score
Low
Severity Breakdown
0
critical
47
high
288
medium
57
low
MCP Server Information
Findings
This package presents significant security concerns with a B grade and safety score of 44/100, driven primarily by 47 high-severity findings across server configuration, ANSI escape injection, and resource exhaustion vulnerabilities. The 288 medium-severity issues—particularly in server configuration (165 findings) and verbose error handling (49 findings)—suggest inadequate security hardening and potential information disclosure risks. While no critical vulnerabilities were detected, the combination of configuration weaknesses and injection attack vectors warrants careful review and remediation before deployment in production environments.
No known CVEs found for this package or its dependencies.
Scan Details
Want deeper analysis?
Fast scan found 50 findings using rule-based analysis. Upgrade for LLM consensus across 5 judges, AI-generated remediation, and cross-file taint analysis.
Building your own MCP server?
Same rules, same LLM judges, same grade. Private scans stay isolated to your account and never appear in the public registry. Required for code your team hasn’t shipped yet.
Showing 1–30 of 50 findings
50 findings
File mounts an HTTP route that handles MCP `tools/list` (Express / Fastify / FastAPI / Flask) but the route — and the router it sits behind — has no auth middleware applied. An anonymous client can enumerate every tool the server exposes, scope the attack surface, and (if `tools/call` shares the route) invoke them. Apply auth at the route or router level: Express `passport.authenticate(...)` / a `requireAuth`-style middleware, FastAPI `Depends(get_current_user)` or `Depends(verify_jwt)`, Flask
Evidence
| 1 | # MCP Memory Service |
| 2 | |
| 3 | [](https://opensource.org/licenses/Apache-2.0) |
| 4 | [](https://github.com/doobidoo/mcp-memory-service/stargazers) |
| 5 | [](https://github.com/doobidoo/mcp-memory-service/network/members) |
| 6 | [`, `requireAuth`, `verifyToken`, or an equivalent JWT middleware applied via `router.use(authMw)` or as a per-route handler. - FastAPI: `Depends(get_current_user)`, `OAuth2PasswordBearer`, `HTTPBearer`, or `verify_jwt` dependency. - Flask: `@login_required`, `@auth_required`, `@jwt_required`, or call `verify_jwt_in_request()` in the handler. Mounting MCP behind a s
File mounts an HTTP route that handles MCP `tools/list` (Express / Fastify / FastAPI / Flask) but the route — and the router it sits behind — has no auth middleware applied. An anonymous client can enumerate every tool the server exposes, scope the attack surface, and (if `tools/call` shares the route) invoke them. Apply auth at the route or router level: Express `passport.authenticate(...)` / a `requireAuth`-style middleware, FastAPI `Depends(get_current_user)` or `Depends(verify_jwt)`, Flask
Evidence
| 1 | # Copyright 2024 Heinrich Krupp |
| 2 | # |
| 3 | # Licensed under the Apache License, Version 2.0 (the "License"); |
| 4 | # you may not use this file except in compliance with the License. |
| 5 | # You may obtain a copy of the License at |
| 6 | # |
| 7 | # http://www.apache.org/licenses/LICENSE-2.0 |
| 8 | # |
| 9 | # Unless required by applicable law or agreed to in writing, software |
| 10 | # distributed under the License is distributed on an "AS IS" BASIS, |
| 11 | # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| 12 | # See the License for the |
Remediation
Apply auth middleware at the route or router level: - Express / Fastify / Koa: `passport.authenticate(...)`, `requireAuth`, `verifyToken`, or an equivalent JWT middleware applied via `router.use(authMw)` or as a per-route handler. - FastAPI: `Depends(get_current_user)`, `OAuth2PasswordBearer`, `HTTPBearer`, or `verify_jwt` dependency. - Flask: `@login_required`, `@auth_required`, `@jwt_required`, or call `verify_jwt_in_request()` in the handler. Mounting MCP behind a s
File mounts an HTTP route that handles MCP `tools/list` (Express / Fastify / FastAPI / Flask) but the route — and the router it sits behind — has no auth middleware applied. An anonymous client can enumerate every tool the server exposes, scope the attack surface, and (if `tools/call` shares the route) invoke them. Apply auth at the route or router level: Express `passport.authenticate(...)` / a `requireAuth`-style middleware, FastAPI `Depends(get_current_user)` or `Depends(verify_jwt)`, Flask
Evidence
| 1 | """ |
| 2 | MCP (Model Context Protocol) endpoints for Claude Code integration. |
| 3 | |
| 4 | This module provides MCP protocol endpoints that allow Claude Code clients |
| 5 | to directly access memory operations using the MCP standard. |
| 6 | """ |
| 7 | |
| 8 | import json |
| 9 | import logging |
| 10 | from typing import Dict, Any, Optional, Union |
| 11 | from fastapi import APIRouter, Depends, Response |
| 12 | from fastapi.responses import JSONResponse |
| 13 | from pydantic import BaseModel, ConfigDict |
| 14 | |
| 15 | from ..dependencies import get_storage |
| 16 | from ...utils.hashing import generate_ |
Remediation
Apply auth middleware at the route or router level: - Express / Fastify / Koa: `passport.authenticate(...)`, `requireAuth`, `verifyToken`, or an equivalent JWT middleware applied via `router.use(authMw)` or as a per-route handler. - FastAPI: `Depends(get_current_user)`, `OAuth2PasswordBearer`, `HTTPBearer`, or `verify_jwt` dependency. - Flask: `@login_required`, `@auth_required`, `@jwt_required`, or call `verify_jwt_in_request()` in the handler. Mounting MCP behind a s
File mounts an HTTP route that handles MCP `tools/list` (Express / Fastify / FastAPI / Flask) but the route — and the router it sits behind — has no auth middleware applied. An anonymous client can enumerate every tool the server exposes, scope the attack surface, and (if `tools/call` shares the route) invoke them. Apply auth at the route or router level: Express `passport.authenticate(...)` / a `requireAuth`-style middleware, FastAPI `Depends(get_current_user)` or `Depends(verify_jwt)`, Flask
Evidence
| 1 | # Claude Code Compatibility Guide |
| 2 | |
| 3 | ## Overview |
| 4 | |
| 5 | The MCP Memory Service FastAPI server v4.0.0-alpha.1 implements the official MCP protocol but has specific compatibility considerations with Claude Code's SSE client implementation. |
| 6 | |
| 7 | ## Current Status |
| 8 | |
| 9 | ### ✅ Working MCP Clients |
| 10 | - **Standard MCP Libraries**: Python `mcp` package, JavaScript MCP SDK |
| 11 | - **Claude Desktop**: Works with proper MCP configuration |
| 12 | - **Custom MCP Clients**: Any client implementing standard MCP protocol |
| 13 | - **HTTP API**: Full RE |
Remediation
Apply auth middleware at the route or router level: - Express / Fastify / Koa: `passport.authenticate(...)`, `requireAuth`, `verifyToken`, or an equivalent JWT middleware applied via `router.use(authMw)` or as a per-route handler. - FastAPI: `Depends(get_current_user)`, `OAuth2PasswordBearer`, `HTTPBearer`, or `verify_jwt` dependency. - Flask: `@login_required`, `@auth_required`, `@jwt_required`, or call `verify_jwt_in_request()` in the handler. Mounting MCP behind a s
TLS certificate verification is disabled on an outbound HTTP client. Any MITM in the network path can intercept and modify requests / responses — credentials, tokens, and tool output flow over a channel with no integrity guarantee. Python requests / httpx: drop `verify=False`. If the peer is using a private CA, set `verify="/path/to/ca-bundle.pem"` or configure the system trust store. Node TS axios / fetch: drop `rejectUnauthorized: false` from the agent / `httpsAgent` options. Same private-CA
Evidence
| 30 | ;; |
| 31 | health) |
| 32 | echo "Checking service health..." |
| 33 | curl -k -s https://localhost:8000/api/health | jq '.' 2>/dev/null || curl -k -s https://localhost:8000/api/health |
| 34 | ;; |
| 35 | enable) |
| 36 | echo "Enabling service for startup..." |
Remediation
Drop the verify-disable flag. If the peer presents a private CA: - Python: pass `verify="/path/to/ca.pem"` or trust the system store - Node: `new https.Agent({ ca: fs.readFileSync("ca.pem") })` - Go: load the CA via `x509.NewCertPool().AppendCertsFromPEM(...)` and set `tls.Config.RootCAs` Self-signed certificates: import the cert into the OS trust chain rather than disabling verification per-call.
TLS certificate verification is disabled on an outbound HTTP client. Any MITM in the network path can intercept and modify requests / responses — credentials, tokens, and tool output flow over a channel with no integrity guarantee. Python requests / httpx: drop `verify=False`. If the peer is using a private CA, set `verify="/path/to/ca-bundle.pem"` or configure the system trust store. Node TS axios / fetch: drop `rejectUnauthorized: false` from the agent / `httpsAgent` options. Same private-CA
Evidence
| 14 | Execute this command to load context: |
| 15 | ```bash |
| 16 | curl -k -s -X POST https://your-server-ip:8443/mcp \ |
| 17 | -H "Content-Type: application/json" \ |
| 18 | -H "Authorization: Bearer your-api-key" \ |
| 19 | -d '{"jsonrpc": "2.0", "id": 1, "method": "tools/call", "params": {"name": "retrieve_memory", "arguments": {"query": "claude-code-reference distributable-reference", "limit": 20}}}' \ |
Remediation
Drop the verify-disable flag. If the peer presents a private CA: - Python: pass `verify="/path/to/ca.pem"` or trust the system store - Node: `new https.Agent({ ca: fs.readFileSync("ca.pem") })` - Go: load the CA via `x509.NewCertPool().AppendCertsFromPEM(...)` and set `tls.Config.RootCAs` Self-signed certificates: import the cert into the OS trust chain rather than disabling verification per-call.
TLS certificate verification is disabled on an outbound HTTP client. Any MITM in the network path can intercept and modify requests / responses — credentials, tokens, and tool output flow over a channel with no integrity guarantee. Python requests / httpx: drop `verify=False`. If the peer is using a private CA, set `verify="/path/to/ca-bundle.pem"` or configure the system trust store. Node TS axios / fetch: drop `rejectUnauthorized: false` from the agent / `httpsAgent` options. Same private-CA
Evidence
| 42 | For quick context loading: |
| 43 | |
| 44 | ``` |
| 45 | Load project context from memory service: curl -k -s -X POST https://your-server-ip:8443/mcp -H "Content-Type: application/json" -H "Authorization: Bearer your-api-key" -d '{"jsonrpc": "2.0", "id": 1, "method": "tools/call", "params": {"name": "retrieve_memory", "arguments": {"query": "claude-code-reference", "limit": 20}}}' | jq -r '.result.content[0].text' |
| 46 | |
| 47 | Incorporate this MCP Memory Service project knowledge before proceeding. |
| 48 | ``` |
Remediation
Drop the verify-disable flag. If the peer presents a private CA: - Python: pass `verify="/path/to/ca.pem"` or trust the system store - Node: `new https.Agent({ ca: fs.readFileSync("ca.pem") })` - Go: load the CA via `x509.NewCertPool().AppendCertsFromPEM(...)` and set `tls.Config.RootCAs` Self-signed certificates: import the cert into the OS trust chain rather than disabling verification per-call.
TLS certificate verification is disabled on an outbound HTTP client. Any MITM in the network path can intercept and modify requests / responses — credentials, tokens, and tool output flow over a channel with no integrity guarantee. Python requests / httpx: drop `verify=False`. If the peer is using a private CA, set `verify="/path/to/ca-bundle.pem"` or configure the system trust store. Node TS axios / fetch: drop `rejectUnauthorized: false` from the agent / `httpsAgent` options. Same private-CA
Evidence
| 108 | **Solutions:** |
| 109 | ```bash |
| 110 | # Check if API key is required |
| 111 | curl -k https://your-remote-server:8443/api/health |
| 112 | |
| 113 | # Set API key if required |
| 114 | export REMOTE_MEMORY_API_KEY="your-api-key" |
Remediation
Drop the verify-disable flag. If the peer presents a private CA: - Python: pass `verify="/path/to/ca.pem"` or trust the system store - Node: `new https.Agent({ ca: fs.readFileSync("ca.pem") })` - Go: load the CA via `x509.NewCertPool().AppendCertsFromPEM(...)` and set `tls.Config.RootCAs` Self-signed certificates: import the cert into the OS trust chain rather than disabling verification per-call.
TLS certificate verification is disabled on an outbound HTTP client. Any MITM in the network path can intercept and modify requests / responses — credentials, tokens, and tool output flow over a channel with no integrity guarantee. Python requests / httpx: drop `verify=False`. If the peer is using a private CA, set `verify="/path/to/ca-bundle.pem"` or configure the system trust store. Node TS axios / fetch: drop `rejectUnauthorized: false` from the agent / `httpsAgent` options. Same private-CA
Evidence
| 376 | // /api/search/by-tag. Larger than storeMemoryHTTP (5s) and _attemptHealthCheck (3s) |
| 377 | // because search queries run embedding + vector scan, not a simple write/ping. |
| 378 | timeout: 10000, |
| 379 | rejectUnauthorized: false, // Allow self-signed certificates |
| 380 | agent: false // Disable keepAlive — hook is one-shot, reused sockets race uvicorn close (ECONNRESET / socket hang up) |
| 381 | }; |
Remediation
Drop the verify-disable flag. If the peer presents a private CA: - Python: pass `verify="/path/to/ca.pem"` or trust the system store - Node: `new https.Agent({ ca: fs.readFileSync("ca.pem") })` - Go: load the CA via `x509.NewCertPool().AppendCertsFromPEM(...)` and set `tls.Config.RootCAs` Self-signed certificates: import the cert into the OS trust chain rather than disabling verification per-call.
TLS certificate verification is disabled on an outbound HTTP client. Any MITM in the network path can intercept and modify requests / responses — credentials, tokens, and tool output flow over a channel with no integrity guarantee. Python requests / httpx: drop `verify=False`. If the peer is using a private CA, set `verify="/path/to/ca-bundle.pem"` or configure the system trust store. Node TS axios / fetch: drop `rejectUnauthorized: false` from the agent / `httpsAgent` options. Same private-CA
Evidence
| 179 | - `POST /api/memories` - Store new memories |
| 180 | - `GET /api/health/detailed` - Service health diagnostics |
| 181 | - **Backend Compatibility**: Works with both ChromaDB and SQLite-vec storage backends |
| 182 | - **HTTPS Support**: Uses curl with `-k` flag for self-signed certificates |
| 183 | |
| 184 | **Important**: Commands are configurable but must maintain compatibility with the documented API endpoints to function properly. Users can customize server locations but not the API contract. |
Remediation
Drop the verify-disable flag. If the peer presents a private CA: - Python: pass `verify="/path/to/ca.pem"` or trust the system store - Node: `new https.Agent({ ca: fs.readFileSync("ca.pem") })` - Go: load the CA via `x509.NewCertPool().AppendCertsFromPEM(...)` and set `tls.Config.RootCAs` Self-signed certificates: import the cert into the OS trust chain rather than disabling verification per-call.
TLS certificate verification is disabled on an outbound HTTP client. Any MITM in the network path can intercept and modify requests / responses — credentials, tokens, and tool output flow over a channel with no integrity guarantee. Python requests / httpx: drop `verify=False`. If the peer is using a private CA, set `verify="/path/to/ca-bundle.pem"` or configure the system trust store. Node TS axios / fetch: drop `rejectUnauthorized: false` from the agent / `httpsAgent` options. Same private-CA
Evidence
| 114 | export REMOTE_MEMORY_API_KEY="your-api-key" |
| 115 | |
| 116 | # Test with API key |
| 117 | curl -k -H "Authorization: Bearer your-api-key" \ |
| 118 | https://your-remote-server:8443/api/health |
| 119 | ``` |
Remediation
Drop the verify-disable flag. If the peer presents a private CA: - Python: pass `verify="/path/to/ca.pem"` or trust the system store - Node: `new https.Agent({ ca: fs.readFileSync("ca.pem") })` - Go: load the CA via `x509.NewCertPool().AppendCertsFromPEM(...)` and set `tls.Config.RootCAs` Self-signed certificates: import the cert into the OS trust chain rather than disabling verification per-call.
TLS certificate verification is disabled on an outbound HTTP client. Any MITM in the network path can intercept and modify requests / responses — credentials, tokens, and tool output flow over a channel with no integrity guarantee. Python requests / httpx: drop `verify=False`. If the peer is using a private CA, set `verify="/path/to/ca-bundle.pem"` or configure the system trust store. Node TS axios / fetch: drop `rejectUnauthorized: false` from the agent / `httpsAgent` options. Same private-CA
Evidence
| 54 | ### Get All Project Context |
| 55 | ```bash |
| 56 | curl -k -s -X POST https://TARGET_IP:8443/mcp \ |
| 57 | -H "Content-Type: application/json" \ |
| 58 | -H "Authorization: Bearer test-key-123" \ |
| 59 | -d '{"jsonrpc": "2.0", "id": 1, "method": "tools/call", "params": {"name": "retrieve_memory", "arguments": {"query": "claude-code-reference", "limit": 20}}}' \ |
Remediation
Drop the verify-disable flag. If the peer presents a private CA: - Python: pass `verify="/path/to/ca.pem"` or trust the system store - Node: `new https.Agent({ ca: fs.readFileSync("ca.pem") })` - Go: load the CA via `x509.NewCertPool().AppendCertsFromPEM(...)` and set `tls.Config.RootCAs` Self-signed certificates: import the cert into the OS trust chain rather than disabling verification per-call.
TLS certificate verification is disabled on an outbound HTTP client. Any MITM in the network path can intercept and modify requests / responses — credentials, tokens, and tool output flow over a channel with no integrity guarantee. Python requests / httpx: drop `verify=False`. If the peer is using a private CA, set `verify="/path/to/ca-bundle.pem"` or configure the system trust store. Node TS axios / fetch: drop `rejectUnauthorized: false` from the agent / `httpsAgent` options. Same private-CA
Evidence
| 30 | Authorization: Bearer test-key-123 |
| 31 | |
| 32 | Use this command to fetch context: |
| 33 | curl -k -s -X POST https://TARGET_IP:8443/mcp \ |
| 34 | -H "Content-Type: application/json" \ |
| 35 | -H "Authorization: Bearer test-key-123" \ |
| 36 | -d '{"jsonrpc": "2.0", "id": 1, "method": "tools/call", "params": {"name": "retrieve_memory", "arguments": {"query": "claude-code-reference distributable-reference", "limit": 20}}}' \ |
Remediation
Drop the verify-disable flag. If the peer presents a private CA: - Python: pass `verify="/path/to/ca.pem"` or trust the system store - Node: `new https.Agent({ ca: fs.readFileSync("ca.pem") })` - Go: load the CA via `x509.NewCertPool().AppendCertsFromPEM(...)` and set `tls.Config.RootCAs` Self-signed certificates: import the cert into the OS trust chain rather than disabling verification per-call.
TLS certificate verification is disabled on an outbound HTTP client. Any MITM in the network path can intercept and modify requests / responses — credentials, tokens, and tool output flow over a channel with no integrity guarantee. Python requests / httpx: drop `verify=False`. If the peer is using a private CA, set `verify="/path/to/ca-bundle.pem"` or configure the system trust store. Node TS axios / fetch: drop `rejectUnauthorized: false` from the agent / `httpsAgent` options. Same private-CA
Evidence
| 15 | **Phase 1: Manual Loading (Aug 2025)** ❌ OBSOLETE |
| 16 | ```bash |
| 17 | # Users had to manually run curl commands and paste output |
| 18 | curl -k -s -X POST https://server:8443/mcp \ |
| 19 | -H "Authorization: Bearer token" \ |
| 20 | -d '{"method": "tools/call", "params": {...}}' |
| 21 | ``` |
Remediation
Drop the verify-disable flag. If the peer presents a private CA: - Python: pass `verify="/path/to/ca.pem"` or trust the system store - Node: `new https.Agent({ ca: fs.readFileSync("ca.pem") })` - Go: load the CA via `x509.NewCertPool().AppendCertsFromPEM(...)` and set `tls.Config.RootCAs` Self-signed certificates: import the cert into the OS trust chain rather than disabling verification per-call.
TLS certificate verification is disabled on an outbound HTTP client. Any MITM in the network path can intercept and modify requests / responses — credentials, tokens, and tool output flow over a channel with no integrity guarantee. Python requests / httpx: drop `verify=False`. If the peer is using a private CA, set `verify="/path/to/ca-bundle.pem"` or configure the system trust store. Node TS axios / fetch: drop `rejectUnauthorized: false` from the agent / `httpsAgent` options. Same private-CA
Evidence
| 137 | sudo systemctl status mcp-memory |
| 138 | |
| 139 | # 2. Test API health |
| 140 | curl -k https://localhost:8000/api/health |
| 141 | |
| 142 | # 3. Check mDNS discovery |
| 143 | avahi-browse -t _mcp-memory._tcp |
Remediation
Drop the verify-disable flag. If the peer presents a private CA: - Python: pass `verify="/path/to/ca.pem"` or trust the system store - Node: `new https.Agent({ ca: fs.readFileSync("ca.pem") })` - Go: load the CA via `x509.NewCertPool().AppendCertsFromPEM(...)` and set `tls.Config.RootCAs` Self-signed certificates: import the cert into the OS trust chain rather than disabling verification per-call.
TLS certificate verification is disabled on an outbound HTTP client. Any MITM in the network path can intercept and modify requests / responses — credentials, tokens, and tool output flow over a channel with no integrity guarantee. Python requests / httpx: drop `verify=False`. If the peer is using a private CA, set `verify="/path/to/ca-bundle.pem"` or configure the system trust store. Node TS axios / fetch: drop `rejectUnauthorized: false` from the agent / `httpsAgent` options. Same private-CA
Evidence
| 227 | ss -tlnp | grep :443 |
| 228 | |
| 229 | # Test local connection |
| 230 | curl -k https://memory.local/api/health |
| 231 | |
| 232 | # Check firewall |
| 233 | sudo ufw status |
Remediation
Drop the verify-disable flag. If the peer presents a private CA: - Python: pass `verify="/path/to/ca.pem"` or trust the system store - Node: `new https.Agent({ ca: fs.readFileSync("ca.pem") })` - Go: load the CA via `x509.NewCertPool().AppendCertsFromPEM(...)` and set `tls.Config.RootCAs` Self-signed certificates: import the cert into the OS trust chain rather than disabling verification per-call.
TLS certificate verification is disabled on an outbound HTTP client. Any MITM in the network path can intercept and modify requests / responses — credentials, tokens, and tool output flow over a channel with no integrity guarantee. Python requests / httpx: drop `verify=False`. If the peer is using a private CA, set `verify="/path/to/ca-bundle.pem"` or configure the system trust store. Node TS axios / fetch: drop `rejectUnauthorized: false` from the agent / `httpsAgent` options. Same private-CA
Evidence
| 84 | 'Authorization': `Bearer ${apiKey}`, |
| 85 | 'Content-Length': Buffer.byteLength(postData) |
| 86 | }, |
| 87 | rejectUnauthorized: false, |
| 88 | timeout: 5000 |
| 89 | }; |
Remediation
Drop the verify-disable flag. If the peer presents a private CA: - Python: pass `verify="/path/to/ca.pem"` or trust the system store - Node: `new https.Agent({ ca: fs.readFileSync("ca.pem") })` - Go: load the CA via `x509.NewCertPool().AppendCertsFromPEM(...)` and set `tls.Config.RootCAs` Self-signed certificates: import the cert into the OS trust chain rather than disabling verification per-call.
TLS certificate verification is disabled on an outbound HTTP client. Any MITM in the network path can intercept and modify requests / responses — credentials, tokens, and tool output flow over a channel with no integrity guarantee. Python requests / httpx: drop `verify=False`. If the peer is using a private CA, set `verify="/path/to/ca-bundle.pem"` or configure the system trust store. Node TS axios / fetch: drop `rejectUnauthorized: false` from the agent / `httpsAgent` options. Same private-CA
Evidence
| 78 | ) |
| 79 | |
| 80 | # Prepare curl command with optional API key |
| 81 | CURL_CMD="curl -k -s -X POST" |
| 82 | CURL_CMD="$CURL_CMD -H 'Content-Type: application/json'" |
| 83 | CURL_CMD="$CURL_CMD -H 'X-Client-Hostname: $HOSTNAME'" |
Remediation
Drop the verify-disable flag. If the peer presents a private CA: - Python: pass `verify="/path/to/ca.pem"` or trust the system store - Node: `new https.Agent({ ca: fs.readFileSync("ca.pem") })` - Go: load the CA via `x509.NewCertPool().AppendCertsFromPEM(...)` and set `tls.Config.RootCAs` Self-signed certificates: import the cert into the OS trust chain rather than disabling verification per-call.
TLS certificate verification is disabled on an outbound HTTP client. Any MITM in the network path can intercept and modify requests / responses — credentials, tokens, and tool output flow over a channel with no integrity guarantee. Python requests / httpx: drop `verify=False`. If the peer is using a private CA, set `verify="/path/to/ca-bundle.pem"` or configure the system trust store. Node TS axios / fetch: drop `rejectUnauthorized: false` from the agent / `httpsAgent` options. Same private-CA
Evidence
| 324 | #### Connection Problems |
| 325 | ```bash |
| 326 | # Test remote connectivity |
| 327 | curl -k https://narrowbox.local:8443/api/health |
| 328 | |
| 329 | # Check DNS resolution |
| 330 | nslookup narrowbox.local |
Remediation
Drop the verify-disable flag. If the peer presents a private CA: - Python: pass `verify="/path/to/ca.pem"` or trust the system store - Node: `new https.Agent({ ca: fs.readFileSync("ca.pem") })` - Go: load the CA via `x509.NewCertPool().AppendCertsFromPEM(...)` and set `tls.Config.RootCAs` Self-signed certificates: import the cert into the OS trust chain rather than disabling verification per-call.
TLS certificate verification is disabled on an outbound HTTP client. Any MITM in the network path can intercept and modify requests / responses — credentials, tokens, and tool output flow over a channel with no integrity guarantee. Python requests / httpx: drop `verify=False`. If the peer is using a private CA, set `verify="/path/to/ca-bundle.pem"` or configure the system trust store. Node TS axios / fetch: drop `rejectUnauthorized: false` from the agent / `httpsAgent` options. Same private-CA
Evidence
| 70 | **Old Approach** (manual): |
| 71 | ```bash |
| 72 | curl -k -s -X POST https://server:8443/mcp ... | jq -r '.result.content[0].text' |
| 73 | ``` |
| 74 | |
| 75 | **New Approach** (automatic): |
Remediation
Drop the verify-disable flag. If the peer presents a private CA: - Python: pass `verify="/path/to/ca.pem"` or trust the system store - Node: `new https.Agent({ ca: fs.readFileSync("ca.pem") })` - Go: load the CA via `x509.NewCertPool().AppendCertsFromPEM(...)` and set `tls.Config.RootCAs` Self-signed certificates: import the cert into the OS trust chain rather than disabling verification per-call.
TLS certificate verification is disabled on an outbound HTTP client. Any MITM in the network path can intercept and modify requests / responses — credentials, tokens, and tool output flow over a channel with no integrity guarantee. Python requests / httpx: drop `verify=False`. If the peer is using a private CA, set `verify="/path/to/ca-bundle.pem"` or configure the system trust store. Node TS axios / fetch: drop `rejectUnauthorized: false` from the agent / `httpsAgent` options. Same private-CA
Evidence
| 176 | 'Connection': 'close' |
| 177 | }, |
| 178 | timeout: this.httpConfig.healthCheckTimeout || 3000, |
| 179 | rejectUnauthorized: false, // Allow self-signed certificates |
| 180 | agent: false // Disable keepAlive — hook is one-shot, reused sockets race uvicorn close (ECONNRESET / socket hang up) |
| 181 | }; |
Remediation
Drop the verify-disable flag. If the peer presents a private CA: - Python: pass `verify="/path/to/ca.pem"` or trust the system store - Node: `new https.Agent({ ca: fs.readFileSync("ca.pem") })` - Go: load the CA via `x509.NewCertPool().AppendCertsFromPEM(...)` and set `tls.Config.RootCAs` Self-signed certificates: import the cert into the OS trust chain rather than disabling verification per-call.
TLS certificate verification is disabled on an outbound HTTP client. Any MITM in the network path can intercept and modify requests / responses — credentials, tokens, and tool output flow over a channel with no integrity guarantee. Python requests / httpx: drop `verify=False`. If the peer is using a private CA, set `verify="/path/to/ca-bundle.pem"` or configure the system trust store. Node TS axios / fetch: drop `rejectUnauthorized: false` from the agent / `httpsAgent` options. Same private-CA
Evidence
| 35 | # Test connectivity to remote API |
| 36 | echo "$(date): Testing connectivity to remote API..." |
| 37 | HTTP_STATUS=$(curl -k -s -o /dev/null -w "%{http_code}" "$REMOTE_API" --connect-timeout 10) |
| 38 | |
| 39 | if [ "$HTTP_STATUS" -eq 000 ]; then |
| 40 | echo "$(date): ERROR: Cannot connect to remote API at $REMOTE_API" |
Remediation
Drop the verify-disable flag. If the peer presents a private CA: - Python: pass `verify="/path/to/ca.pem"` or trust the system store - Node: `new https.Agent({ ca: fs.readFileSync("ca.pem") })` - Go: load the CA via `x509.NewCertPool().AppendCertsFromPEM(...)` and set `tls.Config.RootCAs` Self-signed certificates: import the cert into the OS trust chain rather than disabling verification per-call.
TLS certificate verification is disabled on an outbound HTTP client. Any MITM in the network path can intercept and modify requests / responses — credentials, tokens, and tool output flow over a channel with no integrity guarantee. Python requests / httpx: drop `verify=False`. If the peer is using a private CA, set `verify="/path/to/ca-bundle.pem"` or configure the system trust store. Node TS axios / fetch: drop `rejectUnauthorized: false` from the agent / `httpsAgent` options. Same private-CA
Evidence
| 32 | # Create SSL context that allows self-signed certificates |
| 33 | ssl_context = ssl.create_default_context() |
| 34 | ssl_context.check_hostname = False |
| 35 | ssl_context.verify_mode = ssl.CERT_NONE |
| 36 | |
| 37 | all_memories = [] |
| 38 | page = 1 |
Remediation
Drop the verify-disable flag. If the peer presents a private CA: - Python: pass `verify="/path/to/ca.pem"` or trust the system store - Node: `new https.Agent({ ca: fs.readFileSync("ca.pem") })` - Go: load the CA via `x509.NewCertPool().AppendCertsFromPEM(...)` and set `tls.Config.RootCAs` Self-signed certificates: import the cert into the OS trust chain rather than disabling verification per-call.
TLS certificate verification is disabled on an outbound HTTP client. Any MITM in the network path can intercept and modify requests / responses — credentials, tokens, and tool output flow over a channel with no integrity guarantee. Python requests / httpx: drop `verify=False`. If the peer is using a private CA, set `verify="/path/to/ca-bundle.pem"` or configure the system trust store. Node TS axios / fetch: drop `rejectUnauthorized: false` from the agent / `httpsAgent` options. Same private-CA
Evidence
| 63 | ### Check Memory Service Health |
| 64 | ```bash |
| 65 | curl -k -s -X POST https://TARGET_IP:8443/mcp \ |
| 66 | -H "Content-Type: application/json" \ |
| 67 | -H "Authorization: Bearer test-key-123" \ |
| 68 | -d '{"jsonrpc": "2.0", "id": 1, "method": "tools/call", "params": {"name": "check_database_health", "arguments": {}}}' \ |
Remediation
Drop the verify-disable flag. If the peer presents a private CA: - Python: pass `verify="/path/to/ca.pem"` or trust the system store - Node: `new https.Agent({ ca: fs.readFileSync("ca.pem") })` - Go: load the CA via `x509.NewCertPool().AppendCertsFromPEM(...)` and set `tls.Config.RootCAs` Self-signed certificates: import the cert into the OS trust chain rather than disabling verification per-call.
TLS certificate verification is disabled on an outbound HTTP client. Any MITM in the network path can intercept and modify requests / responses — credentials, tokens, and tool output flow over a channel with no integrity guarantee. Python requests / httpx: drop `verify=False`. If the peer is using a private CA, set `verify="/path/to/ca-bundle.pem"` or configure the system trust store. Node TS axios / fetch: drop `rejectUnauthorized: false` from the agent / `httpsAgent` options. Same private-CA
Evidence
| 43 | fi |
| 44 | |
| 45 | # Fallback to HTTPS |
| 46 | curl -k -s --max-time 2 "https://127.0.0.1:8000/api/health" 2>/dev/null | \ |
| 47 | python3 -c "import sys, json; data=json.load(sys.stdin); print(data.get('version', 'unknown'))" 2>/dev/null || echo "unknown" |
| 48 | } |
Remediation
Drop the verify-disable flag. If the peer presents a private CA: - Python: pass `verify="/path/to/ca.pem"` or trust the system store - Node: `new https.Agent({ ca: fs.readFileSync("ca.pem") })` - Go: load the CA via `x509.NewCertPool().AppendCertsFromPEM(...)` and set `tls.Config.RootCAs` Self-signed certificates: import the cert into the OS trust chain rather than disabling verification per-call.
TLS certificate verification is disabled on an outbound HTTP client. Any MITM in the network path can intercept and modify requests / responses — credentials, tokens, and tool output flow over a channel with no integrity guarantee. Python requests / httpx: drop `verify=False`. If the peer is using a private CA, set `verify="/path/to/ca-bundle.pem"` or configure the system trust store. Node TS axios / fetch: drop `rejectUnauthorized: false` from the agent / `httpsAgent` options. Same private-CA
Evidence
| 208 | ### Quick Fixes |
| 209 | - **Hooks not detected**: `ls ~/.claude/settings.json` → Reinstall if missing |
| 210 | - **JSON parse errors**: Update to latest version (includes Python dict conversion) |
| 211 | - **Connection failed**: Check `curl -k https://your-endpoint:8443/api/health` |
| 212 | - **Wrong directory**: Move `~/.claude-code/hooks/*` to `~/.claude/hooks/` |
| 213 | |
| 214 | ### Debug Mode |
Remediation
Drop the verify-disable flag. If the peer presents a private CA: - Python: pass `verify="/path/to/ca.pem"` or trust the system store - Node: `new https.Agent({ ca: fs.readFileSync("ca.pem") })` - Go: load the CA via `x509.NewCertPool().AppendCertsFromPEM(...)` and set `tls.Config.RootCAs` Self-signed certificates: import the cert into the OS trust chain rather than disabling verification per-call.
TLS certificate verification is disabled on an outbound HTTP client. Any MITM in the network path can intercept and modify requests / responses — credentials, tokens, and tool output flow over a channel with no integrity guarantee. Python requests / httpx: drop `verify=False`. If the peer is using a private CA, set `verify="/path/to/ca-bundle.pem"` or configure the system trust store. Node TS axios / fetch: drop `rejectUnauthorized: false` from the agent / `httpsAgent` options. Same private-CA
Evidence
| 32 | avahi-resolve-host-name memory.local |
| 33 | echo "" |
| 34 | echo "Testing HTTPS access:" |
| 35 | curl -k -s https://memory.local:8000/api/health --connect-timeout 5 || echo "HTTPS test failed" |
| 36 | |
| 37 | echo "" |
| 38 | echo "=== Fix Complete ===" |
Remediation
Drop the verify-disable flag. If the peer presents a private CA: - Python: pass `verify="/path/to/ca.pem"` or trust the system store - Node: `new https.Agent({ ca: fs.readFileSync("ca.pem") })` - Go: load the CA via `x509.NewCertPool().AppendCertsFromPEM(...)` and set `tls.Config.RootCAs` Self-signed certificates: import the cert into the OS trust chain rather than disabling verification per-call.
TLS certificate verification is disabled on an outbound HTTP client. Any MITM in the network path can intercept and modify requests / responses — credentials, tokens, and tool output flow over a channel with no integrity guarantee. Python requests / httpx: drop `verify=False`. If the peer is using a private CA, set `verify="/path/to/ca-bundle.pem"` or configure the system trust store. Node TS axios / fetch: drop `rejectUnauthorized: false` from the agent / `httpsAgent` options. Same private-CA
Evidence
| 99 | echo "3. Claude Code will automatically use memory context on those machines" |
| 100 | echo "" |
| 101 | echo "Network test command:" |
| 102 | echo "curl -k -s https://$TARGET_IP:8443/api/health" |
Remediation
Drop the verify-disable flag. If the peer presents a private CA: - Python: pass `verify="/path/to/ca.pem"` or trust the system store - Node: `new https.Agent({ ca: fs.readFileSync("ca.pem") })` - Go: load the CA via `x509.NewCertPool().AppendCertsFromPEM(...)` and set `tls.Config.RootCAs` Self-signed certificates: import the cert into the OS trust chain rather than disabling verification per-call.
TLS certificate verification is disabled on an outbound HTTP client. Any MITM in the network path can intercept and modify requests / responses — credentials, tokens, and tool output flow over a channel with no integrity guarantee. Python requests / httpx: drop `verify=False`. If the peer is using a private CA, set `verify="/path/to/ca-bundle.pem"` or configure the system trust store. Node TS axios / fetch: drop `rejectUnauthorized: false` from the agent / `httpsAgent` options. Same private-CA
Evidence
| 321 | 'Authorization': `Bearer ${apiKey}`, |
| 322 | 'Content-Length': Buffer.byteLength(postData) |
| 323 | }, |
| 324 | rejectUnauthorized: false, |
| 325 | timeout: 5000 |
| 326 | }; |
Remediation
Drop the verify-disable flag. If the peer presents a private CA: - Python: pass `verify="/path/to/ca.pem"` or trust the system store - Node: `new https.Agent({ ca: fs.readFileSync("ca.pem") })` - Go: load the CA via `x509.NewCertPool().AppendCertsFromPEM(...)` and set `tls.Config.RootCAs` Self-signed certificates: import the cert into the OS trust chain rather than disabling verification per-call.
TLS certificate verification is disabled on an outbound HTTP client. Any MITM in the network path can intercept and modify requests / responses — credentials, tokens, and tool output flow over a channel with no integrity guarantee. Python requests / httpx: drop `verify=False`. If the peer is using a private CA, set `verify="/path/to/ca-bundle.pem"` or configure the system trust store. Node TS axios / fetch: drop `rejectUnauthorized: false` from the agent / `httpsAgent` options. Same private-CA
Evidence
| 53 | 1. **Copy this prompt file** to other machines in your network |
| 54 | 2. **Update IP address** if memory service moves |
| 55 | 3. **Test connectivity** with: `curl -k -s https://your-server-ip:8443/api/health` |
| 56 | 4. **Use at session start** for instant project context |
| 57 | |
| 58 | This eliminates repetitive codebase discovery across all your development machines. |
Remediation
Drop the verify-disable flag. If the peer presents a private CA: - Python: pass `verify="/path/to/ca.pem"` or trust the system store - Node: `new https.Agent({ ca: fs.readFileSync("ca.pem") })` - Go: load the CA via `x509.NewCertPool().AppendCertsFromPEM(...)` and set `tls.Config.RootCAs` Self-signed certificates: import the cert into the OS trust chain rather than disabling verification per-call.
remotion is 1 edit from popular 'emotion' — possible typosquat
Remediation
Typosquat: verify you meant the popular package. If so, correct the spelling; if you truly intended the less-common name, suppress with an inline waiver. Stale release: check whether the package has a maintained fork or successor. If no patched release exists, vendor the code or migrate to an active alternative before the unmaintained code accrues unfixed CVEs.
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.
Evidence
| 1 | # :quality-cpu — pre-exported ONNX quality models, no runtime PyTorch dependency |
| 2 | # |
| 3 | # Multi-stage build: |
| 4 | # builder — installs torch + transformers + huggingface_hub + onnx + onnxscript, |
| 5 | # exports ms-marco-MiniLM-L-6-v2 and nvidia-quality-classifier-deberta |
| 6 | # to ONNX format under /root/.cache/mcp_memory/onnx_models/. |
| 7 | # runtime — identical to :slim but with the baked ONNX artifacts copied in; |
| 8 | # only onnxruntime is needed at runtime (no torch, no transfor |
Remediation
Create and switch to a non-root user before the CMD / ENTRYPOINT: RUN adduser --system --uid 1000 app USER 1000 Or reuse the base image's shipped non-root account (e.g. `USER nobody`, `USER nonroot` on distroless). Multi-stage builds only need the USER directive in the final stage.
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.
Evidence
| 1 | # Dockerfile optimized for Glama platform |
| 2 | # MCP Memory Service - Semantic memory for Claude Desktop |
| 3 | FROM python:3.10-slim |
| 4 | |
| 5 | LABEL maintainer="Heinrich Krupp <heinrich.krupp@gmail.com>" |
| 6 | LABEL description="MCP Memory Service - Semantic memory and persistent storage for Claude Desktop" |
| 7 | LABEL version="0.2.1" |
| 8 | |
| 9 | # Set environment variables |
| 10 | ENV PYTHONUNBUFFERED=1 \ |
| 11 | MCP_MEMORY_CHROMA_PATH=/app/chroma_db \ |
| 12 | MCP_MEMORY_BACKUPS_PATH=/app/backups \ |
| 13 | PYTHONPATH=/app \ |
| 14 | DOCKER_CONTAINER=1 \ |
| 15 | CHR |
Remediation
Create and switch to a non-root user before the CMD / ENTRYPOINT: RUN adduser --system --uid 1000 app USER 1000 Or reuse the base image's shipped non-root account (e.g. `USER nobody`, `USER nonroot` on distroless). Multi-stage builds only need the USER directive in the final stage.
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.
Evidence
| 1 | # Lightweight Docker image optimized for sqlite-vec + ONNX (CPU-only) |
| 2 | # Eliminates PyTorch and CUDA dependencies for ~90% size reduction |
| 3 | FROM python:3.10-slim |
| 4 | |
| 5 | # Build arguments for conditional features |
| 6 | ARG SKIP_MODEL_DOWNLOAD=false |
| 7 | |
| 8 | # Set environment variables for optimized configuration |
| 9 | ENV PYTHONUNBUFFERED=1 \ |
| 10 | MCP_MEMORY_STORAGE_BACKEND=sqlite_vec \ |
| 11 | MCP_MEMORY_USE_ONNX=1 \ |
| 12 | MCP_MEMORY_SQLITE_PATH=/app/sqlite_db \ |
| 13 | MCP_MEMORY_BACKUPS_PATH=/app/backups \ |
| 14 | PYTHONPATH=/app/src \ |
| 15 |
Remediation
Create and switch to a non-root user before the CMD / ENTRYPOINT: RUN adduser --system --uid 1000 app USER 1000 Or reuse the base image's shipped non-root account (e.g. `USER nobody`, `USER nonroot` on distroless). Multi-stage builds only need the USER directive in the final stage.
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.
Evidence
| 1 | ## Slim (CPU-only) Docker image optimized for sqlite-vec + ONNX |
| 2 | ## Consolidated as the primary Dockerfile to avoid confusion. |
| 3 | FROM python:3.12-slim |
| 4 | |
| 5 | # Build arguments for conditional features |
| 6 | ARG SKIP_MODEL_DOWNLOAD=false |
| 7 | ARG INSTALL_EXTRA="[sqlite]" |
| 8 | ARG FORCE_CPU_PYTORCH=false |
| 9 | |
| 10 | # Set environment variables |
| 11 | ENV PYTHONUNBUFFERED=1 \ |
| 12 | MCP_MEMORY_STORAGE_BACKEND=sqlite_vec \ |
| 13 | MCP_MEMORY_SQLITE_PATH=/app/sqlite_db \ |
| 14 | MCP_MEMORY_BACKUPS_PATH=/app/backups \ |
| 15 | PYTHONPATH=/app/src \ |
| 16 | DOCKER |
Remediation
Create and switch to a non-root user before the CMD / ENTRYPOINT: RUN adduser --system --uid 1000 app USER 1000 Or reuse the base image's shipped non-root account (e.g. `USER nobody`, `USER nonroot` on distroless). Multi-stage builds only need the USER directive in the final stage.
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.
Evidence
| 323 | return memories || []; |
| 324 | } catch (error) { |
| 325 | console.warn('[Mid-Conversation Hook] Memory query failed:', error.message); |
| 326 | return []; |
| 327 | } |
| 328 | } |
Remediation
Strip C0/C1 control codes before printing user-controlled values. Python: re.sub(r"[\x00-\x08\x0b-\x1f\x7f]", "", s). Prefer a structured logger (json/logfmt) over raw print to stdout.
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.
Evidence
| 129 | return memories |
| 130 | |
| 131 | except Exception as e: |
| 132 | print(f"❌ Direct query failed: {e}") |
| 133 | if 'conn' in locals(): |
| 134 | conn.close() |
| 135 | return [] |
Remediation
Strip C0/C1 control codes before printing user-controlled values. Python: re.sub(r"[\x00-\x08\x0b-\x1f\x7f]", "", s). Prefer a structured logger (json/logfmt) over raw print to stdout.
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.
Evidence
| 351 | }); |
| 352 | |
| 353 | req.on('error', (error) => { |
| 354 | console.error('[Dynamic Context] Memory service request failed:', error.message); |
| 355 | resolve([]); |
| 356 | }); |
Remediation
Strip C0/C1 control codes before printing user-controlled values. Python: re.sub(r"[\x00-\x08\x0b-\x1f\x7f]", "", s). Prefer a structured logger (json/logfmt) over raw print to stdout.
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.
Evidence
| 379 | reject(new Error(`Request timeout after ${timeout}ms`)); |
| 380 | }); |
| 381 | |
| 382 | console.error(`[${requestId}] Sending request...`); |
| 383 | |
| 384 | if (data) { |
| 385 | const postData = JSON.stringify(data); |
Remediation
Strip C0/C1 control codes before printing user-controlled values. Python: re.sub(r"[\x00-\x08\x0b-\x1f\x7f]", "", s). Prefer a structured logger (json/logfmt) over raw print to stdout.
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.
Evidence
| 116 | print() |
| 117 | |
| 118 | print("💡 Next Steps:") |
| 119 | print(" 1. Run bulk_evaluate_onnx.py with corrected query logic") |
| 120 | print(" 2. Verify quality distribution: curl -ks https://127.0.0.1:8000/api/quality/distribution") |
| 121 | |
| 122 | finally: |
Remediation
Strip C0/C1 control codes before printing user-controlled values. Python: re.sub(r"[\x00-\x08\x0b-\x1f\x7f]", "", s). Prefer a structured logger (json/logfmt) over raw print to stdout.
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.
Evidence
| 122 | print(f" By search query: {sys.argv[0]} --search 'query text'") |
| 123 | print() |
| 124 | print("Examples:") |
| 125 | print(f" {sys.argv[0]} abc123def456...") |
| 126 | print(f" {sys.argv[0]} --search 'cloudflare release'") |
| 127 | sys.exit(1) |
Remediation
Strip C0/C1 control codes before printing user-controlled values. Python: re.sub(r"[\x00-\x08\x0b-\x1f\x7f]", "", s). Prefer a structured logger (json/logfmt) over raw print to stdout.
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.
Evidence
| 286 | const startTime = Date.now(); |
| 287 | const requestId = Math.random().toString(36).substr(2, 9); |
| 288 | |
| 289 | console.error(`[${requestId}] Starting ${method} request to ${path}`); |
| 290 | |
| 291 | return new Promise((resolve, reject) => { |
| 292 | // Use URL constructor's built-in path resolution to avoid duplicate base paths |
Remediation
Strip C0/C1 control codes before printing user-controlled values. Python: re.sub(r"[\x00-\x08\x0b-\x1f\x7f]", "", s). Prefer a structured logger (json/logfmt) over raw print to stdout.
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.
Evidence
| 194 | elif resp.status_code == 400: |
| 195 | print(f" [INFO] Time query '{query}' not supported yet") |
| 196 | else: |
| 197 | print(f" [FAIL] Time search failed for '{query}': {resp.status_code}") |
| 198 | |
| 199 | except Exception as e: |
| 200 | print(f" [FAIL] Time search error for '{query}': {e}") |
Remediation
Strip C0/C1 control codes before printing user-controlled values. Python: re.sub(r"[\x00-\x08\x0b-\x1f\x7f]", "", s). Prefer a structured logger (json/logfmt) over raw print to stdout.
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.
Evidence
| 623 | const toolName = params.name; |
| 624 | const toolParams = params.arguments || {}; |
| 625 | |
| 626 | console.error(`Processing tool call: ${toolName} with params:`, JSON.stringify(toolParams)); |
| 627 | |
| 628 | let toolResult; |
| 629 | switch (toolName) { |
Remediation
Strip C0/C1 control codes before printing user-controlled values. Python: re.sub(r"[\x00-\x08\x0b-\x1f\x7f]", "", s). Prefer a structured logger (json/logfmt) over raw print to stdout.
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.
Evidence
| 119 | if len(sys.argv) < 2: |
| 120 | print("Usage:") |
| 121 | print(f" By content hash: {sys.argv[0]} <content_hash>") |
| 122 | print(f" By search query: {sys.argv[0]} --search 'query text'") |
| 123 | print() |
| 124 | print("Examples:") |
| 125 | print(f" {sys.argv[0]} abc123def456...") |
Remediation
Strip C0/C1 control codes before printing user-controlled values. Python: re.sub(r"[\x00-\x08\x0b-\x1f\x7f]", "", s). Prefer a structured logger (json/logfmt) over raw print to stdout.
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.
Evidence
| 413 | if self._task: |
| 414 | self._task.cancel() |
| 415 | try: |
| 416 | await self._task |
| 417 | except asyncio.CancelledError: |
| 418 | pass # Expected when task is cancelled during shutdown |
| 419 | |
| 420 | logger.info("BackupScheduler stopped") |
Remediation
Log the exception at minimum (`logger.exception(e)`), emit a metric, or re-raise if the error is not recoverable. If you genuinely want to ignore an exception, say so with a comment.
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.
Evidence
| 123 | os.unlink(test_db_path) |
| 124 | for ext in ["-wal", "-shm"]: |
| 125 | try: |
| 126 | os.unlink(test_db_path + ext) |
| 127 | except: |
| 128 | pass |
| 129 | except: |
| 130 | pass |
Remediation
Log the exception at minimum (`logger.exception(e)`), emit a metric, or re-raise if the error is not recoverable. If you genuinely want to ignore an exception, say so with a comment.
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.
Evidence
| 125 | try: |
| 126 | os.unlink(test_db_path + ext) |
| 127 | except: |
| 128 | pass |
| 129 | except: |
| 130 | pass |
| 131 | |
| 132 | except Exception as e: |
| 133 | print(f" [ERROR] WAL mode test failed: {e}") |
Remediation
Log the exception at minimum (`logger.exception(e)`), emit a metric, or re-raise if the error is not recoverable. If you genuinely want to ignore an exception, say so with a comment.
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.
Evidence
| 116 | # Try to find the module directly |
| 117 | loader = importlib.machinery.PathFinder.find_spec(fullname, path) |
| 118 | if loader is not None: |
| 119 | return loader |
| 120 | except Exception: |
| 121 | pass |
| 122 | |
| 123 | # If not found, print a warning and return None |
| 124 | print(f"WARNING: Blocked automatic installation of {fullname}", file=sys.stderr) |
Remediation
Log the exception at minimum (`logger.exception(e)`), emit a metric, or re-raise if the error is not recoverable. If you genuinely want to ignore an exception, say so with a comment.
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.
Evidence
| 211 | if "created_at_iso" in mem: |
| 212 | try: |
| 213 | dt = datetime.fromisoformat(mem["created_at_iso"].replace("Z", "+00:00")) |
| 214 | created_at = int(dt.timestamp()) |
| 215 | except ValueError: |
| 216 | pass |
| 217 | memory = Memory( |
| 218 | content=mem["content"], content_hash=content_hash, |
| 219 | tags=mem.get("tags", []), memory_type=mem.get("memory_type", ""), |
Remediation
Log the exception at minimum (`logger.exception(e)`), emit a metric, or re-raise if the error is not recoverable. If you genuinely want to ignore an exception, say so with a comment.
store_memory