@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.
386 lines • 54.5 kB
JavaScript
/**
* DefaultElementProvider - Populates portfolio with default elements from bundled data
*
* This class handles copying default personas, skills, templates, and other elements
* from the NPM package or Git repository to the user's portfolio on first run.
* It ensures users have example content to work with immediately after installation.
*/
import * as fs from 'fs/promises';
import * as path from 'path';
import { fileURLToPath } from 'url';
import { createHash } from 'crypto';
import { logger } from '../utils/logger.js';
import { ElementType } from './types.js';
import { UnicodeValidator } from '../security/validators/unicodeValidator.js';
import { SecurityMonitor } from '../security/securityMonitor.js';
// File operation constants
export const FILE_CONSTANTS = {
ELEMENT_EXTENSION: '.md',
YAML_EXTENSION: '.yaml',
YML_EXTENSION: '.yml',
JSON_EXTENSION: '.json',
MAX_FILE_SIZE: 10 * 1024 * 1024, // 10MB max file size for safety
CHECKSUM_ALGORITHM: 'sha256',
FILE_PERMISSIONS: 0o644,
CHUNK_SIZE: 64 * 1024 // 64KB chunks for reading large files
};
// Internal constants
const DATA_DIR_CACHE_KEY = 'dollhouse_data_dir';
const COPY_RETRY_ATTEMPTS = 3;
const COPY_RETRY_DELAY = 100; // ms
export class DefaultElementProvider {
__dirname;
static cachedDataDir = null;
static populateInProgress = new Map();
config;
constructor(config) {
const __filename = fileURLToPath(import.meta.url);
this.__dirname = path.dirname(__filename);
this.config = {
useDefaultPaths: true,
...config
};
}
/**
* Search paths for bundled data directory
* Ordered by priority - custom paths first, then development/git, then NPM locations
*/
get dataSearchPaths() {
const paths = [];
// Add custom paths first (highest priority)
if (this.config.customDataPaths) {
paths.push(...this.config.customDataPaths);
}
// Add default paths if enabled
if (this.config.useDefaultPaths !== false) {
paths.push(
// Development/Git installation (relative to this file)
path.join(this.__dirname, '../../data'), path.join(this.__dirname, '../../../data'),
// NPM installations - macOS Homebrew
'/opt/homebrew/lib/node_modules/@dollhousemcp/mcp-server/data',
// NPM installations - standard Unix/Linux
'/usr/local/lib/node_modules/@dollhousemcp/mcp-server/data', '/usr/lib/node_modules/@dollhousemcp/mcp-server/data',
// NPM installations - Windows
'C:\\Program Files\\nodejs\\node_modules\\@dollhousemcp\\mcp-server\\data', 'C:\\Program Files (x86)\\nodejs\\node_modules\\@dollhousemcp\\mcp-server\\data',
// NPM installations - Windows with nvm
path.join(process.env.APPDATA || '', 'npm', 'node_modules', '@dollhousemcp', 'mcp-server', 'data'),
// Current working directory (last resort)
path.join(process.cwd(), 'data'));
}
return paths;
}
/**
* Find the bundled data directory by checking each search path
* Uses Promise.allSettled for better performance and caches the result
*/
async findDataDirectory() {
// Return cached value if available
if (DefaultElementProvider.cachedDataDir !== null) {
return DefaultElementProvider.cachedDataDir;
}
// Check all paths in parallel for better performance
const checkPromises = this.dataSearchPaths.map(async (searchPath) => {
try {
const stats = await fs.stat(searchPath);
if (stats.isDirectory()) {
// Verify it contains expected subdirectories
const hasPersonas = await this.directoryExists(path.join(searchPath, 'personas'));
const hasSkills = await this.directoryExists(path.join(searchPath, 'skills'));
if (hasPersonas || hasSkills) {
return searchPath;
}
}
}
catch (error) {
// Directory doesn't exist or can't be accessed
return null;
}
return null;
});
const results = await Promise.allSettled(checkPromises);
// Find the first successful result
for (const result of results) {
if (result.status === 'fulfilled' && result.value !== null) {
logger.info(`[DefaultElementProvider] Found data directory at: ${result.value}`);
// Cache the result
DefaultElementProvider.cachedDataDir = result.value;
return result.value;
}
}
logger.warn('[DefaultElementProvider] No bundled data directory found in any search path');
return null;
}
/**
* Helper to check if a directory exists
*/
async directoryExists(dirPath) {
try {
const stats = await fs.stat(dirPath);
return stats.isDirectory();
}
catch {
return false;
}
}
/**
* Copy all files from source directory to destination directory
* Skips files that already exist to preserve user modifications
*/
async copyElementFiles(sourceDir, destDir, elementType) {
let copiedCount = 0;
try {
// Ensure destination directory exists
await fs.mkdir(destDir, { recursive: true });
// Read source directory
const files = await fs.readdir(sourceDir);
for (const file of files) {
// Only copy markdown files
if (!file.endsWith(FILE_CONSTANTS.ELEMENT_EXTENSION)) {
continue;
}
// Normalize filename for security
const normalizedFile = UnicodeValidator.normalize(file);
if (!normalizedFile.isValid) {
logger.warn(`[DefaultElementProvider] Skipping file with invalid Unicode: ${file}`);
continue;
}
const sourcePath = path.join(sourceDir, normalizedFile.normalizedContent);
const destPath = path.join(destDir, normalizedFile.normalizedContent);
try {
// Check if destination file already exists
await fs.access(destPath);
logger.debug(`[DefaultElementProvider] Skipping existing file: ${normalizedFile.normalizedContent}`);
continue;
}
catch {
// File doesn't exist, proceed with copy
}
try {
// Validate source file before copying
const sourceStats = await fs.stat(sourcePath);
// Check file size limit
if (sourceStats.size > FILE_CONSTANTS.MAX_FILE_SIZE) {
logger.warn(`[DefaultElementProvider] Skipping oversized file ${normalizedFile.normalizedContent}: ` +
`${sourceStats.size} bytes (max: ${FILE_CONSTANTS.MAX_FILE_SIZE} bytes)`, {
file: normalizedFile.normalizedContent,
size: sourceStats.size,
maxSize: FILE_CONSTANTS.MAX_FILE_SIZE,
elementType
});
continue;
}
// Copy the file with verification
await this.copyFileWithVerification(sourcePath, destPath);
copiedCount++;
logger.debug(`[DefaultElementProvider] Copied ${elementType}: ${normalizedFile.normalizedContent}`);
// Log security event for each file copied
SecurityMonitor.logSecurityEvent({
type: 'FILE_COPIED',
severity: 'LOW',
source: 'DefaultElementProvider.copyElementFiles',
details: `Copied default ${elementType} file: ${normalizedFile.normalizedContent}`,
metadata: {
sourcePath,
destPath,
elementType,
fileSize: (await fs.stat(destPath)).size
}
});
}
catch (error) {
const err = error;
logger.error(`[DefaultElementProvider] Failed to copy ${normalizedFile.normalizedContent}`, {
error: err.message,
stack: err.stack,
sourcePath,
destPath,
elementType
});
// Continue with other files instead of failing completely
}
}
if (copiedCount > 0) {
logger.info(`[DefaultElementProvider] Copied ${copiedCount} ${elementType} file(s)`);
}
}
catch (error) {
logger.error(`[DefaultElementProvider] Error copying ${elementType} files:`, error);
}
return copiedCount;
}
/**
* Copy a file with integrity verification
* Ensures the file was copied correctly by comparing sizes
*/
/**
* Calculate checksum of a file for integrity verification
* @param filePath Path to the file
* @returns Hex-encoded checksum
*/
async calculateChecksum(filePath) {
const hash = createHash(FILE_CONSTANTS.CHECKSUM_ALGORITHM);
const stream = await fs.open(filePath, 'r');
try {
const buffer = Buffer.alloc(FILE_CONSTANTS.CHUNK_SIZE);
let bytesRead;
do {
const result = await stream.read(buffer, 0, FILE_CONSTANTS.CHUNK_SIZE);
bytesRead = result.bytesRead;
if (bytesRead > 0) {
hash.update(buffer.subarray(0, bytesRead));
}
} while (bytesRead > 0);
return hash.digest('hex');
}
finally {
await stream.close();
}
}
/**
* Copy file with integrity verification and retry logic
* @param sourcePath Source file path
* @param destPath Destination file path
* @throws Error if copy fails after all retry attempts
*/
async copyFileWithVerification(sourcePath, destPath) {
let lastError = null;
for (let attempt = 1; attempt <= COPY_RETRY_ATTEMPTS; attempt++) {
try {
// Copy the file
await fs.copyFile(sourcePath, destPath);
// Verify size matches
const [sourceStats, destStats] = await Promise.all([
fs.stat(sourcePath),
fs.stat(destPath)
]);
if (sourceStats.size !== destStats.size) {
throw new Error(`Size mismatch after copy - source: ${sourceStats.size} bytes, ` +
`destination: ${destStats.size} bytes`);
}
// Verify checksum matches for complete integrity
const [sourceChecksum, destChecksum] = await Promise.all([
this.calculateChecksum(sourcePath),
this.calculateChecksum(destPath)
]);
if (sourceChecksum !== destChecksum) {
throw new Error(`Checksum mismatch after copy - source: ${sourceChecksum}, ` +
`destination: ${destChecksum}`);
}
// Set proper permissions
try {
await fs.chmod(destPath, FILE_CONSTANTS.FILE_PERMISSIONS);
}
catch (error) {
logger.debug(`[DefaultElementProvider] Could not set permissions on ${destPath}: ${error}`, { sourcePath, destPath, attempt });
}
// Success - file copied and verified
logger.debug(`[DefaultElementProvider] Successfully copied and verified: ${path.basename(sourcePath)}`, { size: sourceStats.size, checksum: sourceChecksum.substring(0, 8) });
return;
}
catch (error) {
lastError = error;
// Clean up failed copy
try {
await fs.unlink(destPath);
}
catch {
// Ignore cleanup errors
}
if (attempt < COPY_RETRY_ATTEMPTS) {
logger.debug(`[DefaultElementProvider] Copy attempt ${attempt} failed, retrying...`, { error: lastError.message, sourcePath, destPath });
await new Promise(resolve => setTimeout(resolve, COPY_RETRY_DELAY * attempt));
}
}
}
// All attempts failed
throw new Error(`Failed to copy ${path.basename(sourcePath)} after ${COPY_RETRY_ATTEMPTS} attempts: ` +
`${lastError?.message || 'Unknown error'}`);
}
/**
* Populate the portfolio with default elements from bundled data
* This is called during portfolio initialization for new installations
* Protected against concurrent calls to prevent race conditions
*/
async populateDefaults(portfolioBaseDir) {
// Check if population is already in progress for this portfolio
const existingPopulation = DefaultElementProvider.populateInProgress.get(portfolioBaseDir);
if (existingPopulation) {
logger.debug('[DefaultElementProvider] Population already in progress for portfolio, waiting...', { portfolioBaseDir });
return existingPopulation;
}
// Create new population promise
const populationPromise = this.performPopulation(portfolioBaseDir)
.finally(() => {
// Clean up when done
DefaultElementProvider.populateInProgress.delete(portfolioBaseDir);
});
DefaultElementProvider.populateInProgress.set(portfolioBaseDir, populationPromise);
return populationPromise;
}
/**
* Perform the actual population of default elements
* @param portfolioBaseDir Base directory of the portfolio
*/
async performPopulation(portfolioBaseDir) {
logger.info('[DefaultElementProvider] Starting default element population', { portfolioBaseDir });
// Log security event for portfolio initialization
SecurityMonitor.logSecurityEvent({
type: 'PORTFOLIO_INITIALIZATION',
severity: 'LOW',
source: 'DefaultElementProvider.performPopulation',
details: `Starting default element population for portfolio: ${portfolioBaseDir}`
});
// Find the bundled data directory
const dataDir = await this.findDataDirectory();
if (!dataDir) {
logger.warn('[DefaultElementProvider] No bundled data directory found - portfolio will start empty', {
searchPaths: this.dataSearchPaths.slice(0, 3), // Log first few paths for debugging
cwd: process.cwd(),
dirname: this.__dirname
});
return;
}
// Track total files copied
let totalCopied = 0;
const copiedCounts = {};
// Copy each element type - directories now match enum values (all plural)
for (const elementType of Object.values(ElementType)) {
const sourceDir = path.join(dataDir, elementType);
const destDir = path.join(portfolioBaseDir, elementType);
try {
// Check if source directory exists
await fs.access(sourceDir);
const copiedCount = await this.copyElementFiles(sourceDir, destDir, elementType);
copiedCounts[elementType] = copiedCount;
totalCopied += copiedCount;
}
catch (error) {
// Source directory doesn't exist, skip
logger.debug(`[DefaultElementProvider] No ${elementType} directory in bundled data`);
}
}
if (totalCopied > 0) {
logger.info(`[DefaultElementProvider] Successfully populated portfolio with ${totalCopied} default element(s)`, {
portfolioBaseDir,
dataDir,
breakdown: copiedCounts
});
// Log security event for successful population
SecurityMonitor.logSecurityEvent({
type: 'PORTFOLIO_POPULATED',
severity: 'LOW',
source: 'DefaultElementProvider.performPopulation',
details: `Successfully populated portfolio with ${totalCopied} default elements`,
metadata: {
portfolioBaseDir,
dataDir,
copiedCounts
}
});
}
else {
logger.info('[DefaultElementProvider] No new elements to copy - portfolio may already have content');
}
}
}
//# sourceMappingURL=data:application/json;base64,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