@dollhousemcp/mcp-server
Version:
DollhouseMCP - A Model Context Protocol (MCP) server that enables dynamic AI persona management from markdown files, allowing Claude and other compatible AI assistants to activate and switch between different behavioral personas.
119 lines • 15.1 kB
JavaScript
/**
* Shared utilities for search functionality
*/
import { UnicodeValidator } from '../security/validators/unicodeValidator.js';
/**
* Normalize search terms for better matching
* Handles spaces, dashes, underscores, and file extensions
*
* @param term - The search term to normalize
* @param maxLength - Maximum allowed length for the search term (default: 1000)
* @returns Normalized search term
* @throws Error if term exceeds maxLength
*/
export function normalizeSearchTerm(term, maxLength = 1000) {
// SECURITY FIX: Normalize Unicode to prevent homograph attacks
const normalized = UnicodeValidator.normalize(term);
const cleanTerm = normalized.normalizedContent;
// Security: Limit input length to prevent DoS attacks
if (cleanTerm.length > maxLength) {
throw new Error(`Search term exceeds maximum length of ${maxLength} characters`);
}
return cleanTerm.toLowerCase()
.replaceAll(/[-_\s]+/g, ' ') // Convert dashes, underscores to spaces
.replace(/\.md$/, '') // Remove .md extension
.trim();
}
/**
* Preserve original structure for partial matching
* Less aggressive normalization that keeps original separators for partial searches
*
* @param term - The search term to normalize
* @param maxLength - Maximum allowed length for the search term (default: 1000)
* @returns Normalized search term with preserved structure
* @throws Error if term exceeds maxLength
*/
export function normalizeForPartialMatch(term, maxLength = 1000) {
// SECURITY FIX: Normalize Unicode to prevent homograph attacks
const normalized = UnicodeValidator.normalize(term);
const cleanTerm = normalized.normalizedContent;
// Security: Limit input length to prevent DoS attacks
if (cleanTerm.length > maxLength) {
throw new Error(`Search term exceeds maximum length of ${maxLength} characters`);
}
return cleanTerm.toLowerCase()
.replace(/\.md$/, '') // Remove .md extension only
.trim();
}
/**
* Check if a search term matches a target string with multiple strategies
* Uses both normalized matching and partial matching for better results
*
* @param searchTerm - The term being searched for
* @param targetString - The string to search in
* @returns true if there's a match
*/
export function isSearchMatch(searchTerm, targetString) {
// Strategy 1: Exact normalized matching
const normalizedSearch = normalizeSearchTerm(searchTerm);
const normalizedTarget = normalizeSearchTerm(targetString);
if (normalizedTarget.includes(normalizedSearch)) {
return true;
}
// Strategy 2: Partial matching with preserved structure
const partialSearch = normalizeForPartialMatch(searchTerm);
const partialTarget = normalizeForPartialMatch(targetString);
if (partialTarget.includes(partialSearch)) {
return true;
}
// Strategy 3: Word-boundary matching
const searchWords = normalizedSearch.split(/\s+/);
const targetWords = normalizedTarget.split(/\s+/);
return searchWords.some(searchWord => targetWords.some(targetWord => targetWord.includes(searchWord)));
}
/**
* Validate search query length and content
*
* @param query - The search query to validate
* @param maxLength - Maximum allowed length (default: 1000)
* @returns true if valid
* @throws Error with descriptive message if invalid
*/
export function validateSearchQuery(query, maxLength = 1000) {
if (!query || query.trim().length === 0) {
throw new Error('Search query cannot be empty');
}
// SECURITY FIX: Normalize Unicode before validation
const normalized = UnicodeValidator.normalize(query);
const cleanQuery = normalized.normalizedContent;
if (cleanQuery.length > maxLength) {
throw new Error(`Search query exceeds maximum length of ${maxLength} characters`);
}
// Check for potential injection patterns (basic validation)
const dangerousPatterns = [
// eslint-disable-next-line no-control-regex -- Intentionally checking for control chars for security
/[\u0000-\u001F\u007F]/, // NOSONAR - Control characters check for security
/[<>]/, // Potential HTML/XML injection
];
for (const pattern of dangerousPatterns) {
if (pattern.test(cleanQuery)) {
throw new Error('Search query contains invalid characters');
}
}
return true;
}
/**
* Debug function to show how search terms are normalized
* Helps troubleshoot search matching issues
*
* @param originalTerm - The original search term
* @returns Object with different normalization results
*/
export function debugNormalization(originalTerm) {
return {
original: originalTerm,
normalized: normalizeSearchTerm(originalTerm),
partialMatch: normalizeForPartialMatch(originalTerm)
};
}
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"searchUtils.js","sourceRoot":"","sources":["../../src/utils/searchUtils.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Shared utilities for search functionality\n */\n\nimport { UnicodeValidator } from '../security/validators/unicodeValidator.js';\n\n/**\n * Normalize search terms for better matching\n * Handles spaces, dashes, underscores, and file extensions\n * \n * @param term - The search term to normalize\n * @param maxLength - Maximum allowed length for the search term (default: 1000)\n * @returns Normalized search term\n * @throws Error if term exceeds maxLength\n */\nexport function normalizeSearchTerm(term: string, maxLength: number = 1000): string {\n  // SECURITY FIX: Normalize Unicode to prevent homograph attacks\n  const normalized = UnicodeValidator.normalize(term);\n  const cleanTerm = normalized.normalizedContent;\n  \n  // Security: Limit input length to prevent DoS attacks\n  if (cleanTerm.length > maxLength) {\n    throw new Error(`Search term exceeds maximum length of ${maxLength} characters`);\n  }\n  \n  return cleanTerm.toLowerCase()\n    .replaceAll(/[-_\\s]+/g, ' ')  // Convert dashes, underscores to spaces\n    .replace(/\\.md$/, '')       // Remove .md extension\n    .trim();\n}\n\n/**\n * Preserve original structure for partial matching\n * Less aggressive normalization that keeps original separators for partial searches\n * \n * @param term - The search term to normalize\n * @param maxLength - Maximum allowed length for the search term (default: 1000)\n * @returns Normalized search term with preserved structure\n * @throws Error if term exceeds maxLength\n */\nexport function normalizeForPartialMatch(term: string, maxLength: number = 1000): string {\n  // SECURITY FIX: Normalize Unicode to prevent homograph attacks\n  const normalized = UnicodeValidator.normalize(term);\n  const cleanTerm = normalized.normalizedContent;\n  \n  // Security: Limit input length to prevent DoS attacks\n  if (cleanTerm.length > maxLength) {\n    throw new Error(`Search term exceeds maximum length of ${maxLength} characters`);\n  }\n  \n  return cleanTerm.toLowerCase()\n    .replace(/\\.md$/, '')       // Remove .md extension only\n    .trim();\n}\n\n/**\n * Check if a search term matches a target string with multiple strategies\n * Uses both normalized matching and partial matching for better results\n * \n * @param searchTerm - The term being searched for\n * @param targetString - The string to search in\n * @returns true if there's a match\n */\nexport function isSearchMatch(searchTerm: string, targetString: string): boolean {\n  // Strategy 1: Exact normalized matching\n  const normalizedSearch = normalizeSearchTerm(searchTerm);\n  const normalizedTarget = normalizeSearchTerm(targetString);\n  if (normalizedTarget.includes(normalizedSearch)) {\n    return true;\n  }\n  \n  // Strategy 2: Partial matching with preserved structure\n  const partialSearch = normalizeForPartialMatch(searchTerm);\n  const partialTarget = normalizeForPartialMatch(targetString);\n  if (partialTarget.includes(partialSearch)) {\n    return true;\n  }\n  \n  // Strategy 3: Word-boundary matching\n  const searchWords = normalizedSearch.split(/\\s+/);\n  const targetWords = normalizedTarget.split(/\\s+/);\n  return searchWords.some(searchWord => \n    targetWords.some(targetWord => targetWord.includes(searchWord))\n  );\n}\n\n/**\n * Validate search query length and content\n * \n * @param query - The search query to validate\n * @param maxLength - Maximum allowed length (default: 1000)\n * @returns true if valid\n * @throws Error with descriptive message if invalid\n */\nexport function validateSearchQuery(query: string, maxLength: number = 1000): boolean {\n  if (!query || query.trim().length === 0) {\n    throw new Error('Search query cannot be empty');\n  }\n  \n  // SECURITY FIX: Normalize Unicode before validation\n  const normalized = UnicodeValidator.normalize(query);\n  const cleanQuery = normalized.normalizedContent;\n  \n  if (cleanQuery.length > maxLength) {\n    throw new Error(`Search query exceeds maximum length of ${maxLength} characters`);\n  }\n  \n  // Check for potential injection patterns (basic validation)\n  const dangerousPatterns = [\n    // eslint-disable-next-line no-control-regex -- Intentionally checking for control chars for security\n    /[\\u0000-\\u001F\\u007F]/,  // NOSONAR - Control characters check for security\n    /[<>]/,             // Potential HTML/XML injection\n  ];\n  \n  for (const pattern of dangerousPatterns) {\n    if (pattern.test(cleanQuery)) {\n      throw new Error('Search query contains invalid characters');\n    }\n  }\n  \n  return true;\n}\n\n/**\n * Debug function to show how search terms are normalized\n * Helps troubleshoot search matching issues\n * \n * @param originalTerm - The original search term\n * @returns Object with different normalization results\n */\nexport function debugNormalization(originalTerm: string) {\n  return {\n    original: originalTerm,\n    normalized: normalizeSearchTerm(originalTerm),\n    partialMatch: normalizeForPartialMatch(originalTerm)\n  };\n}"]}