@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.
290 lines • 41.5 kB
JavaScript
/**
* File-based log sink: writes buffered entries to date-rotated files on disk.
*
* Error reporting in this file intentionally uses `process.stderr.write` rather
* than the application logger. Using the logger would create a circular
* dependency (logger → sink → logger) and risk infinite loops or masking the
* original error. `process.stderr.write` is the correct pattern for any code
* inside the logging subsystem itself.
*/
import os from 'os';
import fs from 'fs/promises';
import path from 'path';
const CATEGORY_PATTERN = /^(application|security|performance|telemetry)-(\d{4}-\d{2}-\d{2})/;
// Captures category, date, optional sequence number, and extension
const ROTATED_FILE_PATTERN = /^(application|security|performance|telemetry)-(\d{4}-\d{2}-\d{2})(?:\.(\d+))?(\.[^.]+)$/;
export class FileLogSink {
logDir;
formatter;
maxFileSize;
retentionDays;
securityRetentionDays;
maxDirSizeBytes;
maxFilesPerCategory;
buffers = new Map();
currentDates = new Map();
sequenceCounters = new Map();
fileSizes = new Map();
initialized = false;
cleanupTimer = null;
constructor(options) {
this.logDir = options.logDir.startsWith('~')
? path.join(os.homedir(), options.logDir.slice(1))
: options.logDir;
this.formatter = options.formatter;
this.maxFileSize = options.maxFileSize;
this.retentionDays = options.retentionDays;
this.securityRetentionDays = options.securityRetentionDays;
this.maxDirSizeBytes = options.maxDirSizeBytes;
this.maxFilesPerCategory = options.maxFilesPerCategory;
}
write(entry) {
const formatted = this.formatter.format(entry);
let buffer = this.buffers.get(entry.category);
if (!buffer) {
buffer = [];
this.buffers.set(entry.category, buffer);
}
buffer.push(formatted);
}
async flush() {
const categoriesToFlush = [];
for (const [category, buffer] of this.buffers) {
if (buffer.length === 0)
continue;
const content = buffer.splice(0).join('');
categoriesToFlush.push([category, content]);
}
if (categoriesToFlush.length === 0)
return;
try {
await this.ensureLogDir();
for (const [category, content] of categoriesToFlush) {
const filePath = await this.resolveFilePath(category, content.length);
await fs.appendFile(filePath, content, { mode: 0o600 });
const currentSize = this.fileSizes.get(category) ?? 0;
this.fileSizes.set(category, currentSize + content.length);
}
}
catch (err) {
// Best-effort: log to stderr, don't throw
process.stderr.write(`[FileLogSink] flush error: ${err}\n`);
}
}
async close() {
await this.flush();
if (this.cleanupTimer !== null) {
clearInterval(this.cleanupTimer);
this.cleanupTimer = null;
}
}
async cleanupExpiredFiles() {
try {
const files = await fs.readdir(this.logDir);
const now = Date.now();
for (const file of files) {
const match = CATEGORY_PATTERN.exec(file);
if (!match)
continue;
const category = match[1];
const dateStr = match[2];
const fileDate = new Date(dateStr + 'T00:00:00Z');
if (isNaN(fileDate.getTime()))
continue;
const ageMs = now - fileDate.getTime();
const ageDays = ageMs / (1000 * 60 * 60 * 24);
const retentionLimit = category === 'security'
? this.securityRetentionDays
: this.retentionDays;
if (ageDays > retentionLimit) {
try {
await fs.unlink(path.join(this.logDir, file));
}
catch {
// best-effort: skip files that can't be deleted
}
}
}
}
catch (err) {
process.stderr.write(`[FileLogSink] cleanup error: ${err}\n`);
}
await this.cleanupByFileCount();
await this.cleanupByDirSize();
}
startCleanupTimer() {
if (this.cleanupTimer !== null)
return;
// Run initial cleanup
void this.cleanupExpiredFiles();
// Schedule every 24 hours
this.cleanupTimer = setInterval(() => {
void this.cleanupExpiredFiles();
}, 24 * 60 * 60 * 1000);
if (this.cleanupTimer && typeof this.cleanupTimer === 'object' && 'unref' in this.cleanupTimer) {
this.cleanupTimer.unref();
}
}
async ensureLogDir() {
if (this.initialized)
return;
await fs.mkdir(this.logDir, { recursive: true, mode: 0o700 });
this.initialized = true;
}
/**
* Scan the log directory to find the highest existing sequence number for a
* given category+date. Used on startup/day-transition to resume from the
* correct file instead of always resetting to sequence 0.
*
* Performance: O(n) over files in the directory, but called at most once per
* category per calendar day (on process start or UTC midnight rollover). For
* deployments with very large log directories, keep DOLLHOUSE_LOG_MAX_FILES_PER_CATEGORY
* set (default 100) so this scan stays fast.
*
* NOTE: no inter-process locking — if two instances share a log dir they may
* both scan and pick the same max seq, then both write to the same file. Each
* instance should use its own dedicated log directory. See the troubleshooting
* guide ("Multiple server instances sharing a log directory") for details.
*/
async scanMaxSequence(category, today) {
try {
const files = await fs.readdir(this.logDir);
let maxSeq = 0;
for (const file of files) {
const m = ROTATED_FILE_PATTERN.exec(file);
if (!m || m[1] !== category || m[2] !== today)
continue;
const seq = m[3] ? parseInt(m[3], 10) : 0;
if (seq > maxSeq)
maxSeq = seq;
}
return maxSeq;
}
catch {
return 0; // log dir doesn't exist yet
}
}
async resolveFilePath(category, contentSize) {
const today = new Date().toISOString().slice(0, 10);
const prevDate = this.currentDates.get(category);
if (prevDate !== today) {
this.currentDates.set(category, today);
// Scan for max existing sequence to handle restarts correctly
const existingMaxSeq = await this.scanMaxSequence(category, today);
this.sequenceCounters.set(category, existingMaxSeq);
this.fileSizes.set(category, 0);
// Stat the highest-sequence file (not just base) to pick up its current size
const suffix = existingMaxSeq > 0 ? `.${existingMaxSeq}` : '';
const targetPath = path.join(this.logDir, `${category}-${today}${suffix}${this.formatter.fileExtension}`);
try {
const stat = await fs.stat(targetPath);
this.fileSizes.set(category, stat.size);
}
catch {
// File doesn't exist yet
}
}
const currentSize = this.fileSizes.get(category) ?? 0;
let seq = this.sequenceCounters.get(category) ?? 0;
// Check if we need to rotate
if (currentSize > 0 && currentSize + contentSize > this.maxFileSize) {
seq++;
this.sequenceCounters.set(category, seq);
this.fileSizes.set(category, 0);
// Stat the new rotated file to get its size
const rotatedPath = path.join(this.logDir, `${category}-${today}.${seq}${this.formatter.fileExtension}`);
try {
const stat = await fs.stat(rotatedPath);
this.fileSizes.set(category, stat.size);
}
catch {
// File doesn't exist yet
}
}
const suffix = seq > 0 ? `.${seq}` : '';
return path.join(this.logDir, `${category}-${today}${suffix}${this.formatter.fileExtension}`);
}
/**
* Delete oldest files per category when the file count exceeds
* `maxFilesPerCategory`. Sorting is date ASC, then seq ASC within
* the same date, so the oldest files are removed first.
*/
async cleanupByFileCount() {
if (this.maxFilesPerCategory === 0)
return;
try {
const files = await fs.readdir(this.logDir);
const byCategory = new Map();
for (const file of files) {
const m = ROTATED_FILE_PATTERN.exec(file);
if (!m)
continue;
const cat = m[1];
if (!byCategory.has(cat))
byCategory.set(cat, []);
byCategory.get(cat).push({ file, date: m[2], seq: m[3] ? parseInt(m[3], 10) : 0 });
}
for (const [, entries] of byCategory) {
if (entries.length <= this.maxFilesPerCategory)
continue;
// Sort oldest first: date ASC, then seq ASC within same date
entries.sort((a, b) => a.date.localeCompare(b.date) || a.seq - b.seq);
const toDelete = entries.slice(0, entries.length - this.maxFilesPerCategory);
for (const entry of toDelete) {
try {
await fs.unlink(path.join(this.logDir, entry.file));
}
catch { /* best-effort */ }
}
}
}
catch (err) {
process.stderr.write(`[FileLogSink] cleanupByFileCount error: ${err}\n`);
}
}
/**
* Delete oldest log files (by mtime) when the total directory size exceeds
* `maxDirSizeBytes`. Emits a stderr warning when a security log is deleted
* so operators can investigate or increase the cap.
*/
async cleanupByDirSize() {
if (this.maxDirSizeBytes === 0)
return;
try {
const files = await fs.readdir(this.logDir);
const entries = [];
for (const file of files) {
if (!ROTATED_FILE_PATTERN.exec(file))
continue;
try {
const stat = await fs.stat(path.join(this.logDir, file));
entries.push({ file, mtime: stat.mtimeMs, size: stat.size, isSecurity: file.startsWith('security-') });
}
catch { /* best-effort */ }
}
const totalSize = entries.reduce((sum, e) => sum + e.size, 0);
if (totalSize <= this.maxDirSizeBytes)
return;
// Sort oldest first by mtime
entries.sort((a, b) => a.mtime - b.mtime);
let remaining = totalSize;
for (const entry of entries) {
if (remaining <= this.maxDirSizeBytes)
break;
if (entry.isSecurity) {
process.stderr.write(`[FileLogSink] dir-size cap: deleting security log ${entry.file} ` +
`(dir=${remaining} > cap=${this.maxDirSizeBytes})\n`);
}
try {
await fs.unlink(path.join(this.logDir, entry.file));
remaining -= entry.size;
}
catch { /* best-effort */ }
}
}
catch (err) {
process.stderr.write(`[FileLogSink] cleanupByDirSize error: ${err}\n`);
}
}
}
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"FileLogSink.js","sourceRoot":"","sources":["../../../src/logging/sinks/FileLogSink.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * File-based log sink: writes buffered entries to date-rotated files on disk.\n *\n * Error reporting in this file intentionally uses `process.stderr.write` rather\n * than the application logger. Using the logger would create a circular\n * dependency (logger → sink → logger) and risk infinite loops or masking the\n * original error. `process.stderr.write` is the correct pattern for any code\n * inside the logging subsystem itself.\n */\n\nimport os from 'os';\nimport fs from 'fs/promises';\nimport path from 'path';\nimport type { ILogSink, ILogFormatter, UnifiedLogEntry, LogCategory } from '../types.js';\n\nexport interface FileLogSinkOptions {\n  logDir: string;\n  formatter: ILogFormatter;\n  maxFileSize: number;\n  retentionDays: number;\n  securityRetentionDays: number;\n  maxDirSizeBytes: number;\n  maxFilesPerCategory: number;\n}\n\nconst CATEGORY_PATTERN = /^(application|security|performance|telemetry)-(\\d{4}-\\d{2}-\\d{2})/;\n\n// Captures category, date, optional sequence number, and extension\nconst ROTATED_FILE_PATTERN = /^(application|security|performance|telemetry)-(\\d{4}-\\d{2}-\\d{2})(?:\\.(\\d+))?(\\.[^.]+)$/;\n\nexport class FileLogSink implements ILogSink {\n  private readonly logDir: string;\n  private readonly formatter: ILogFormatter;\n  private readonly maxFileSize: number;\n  private readonly retentionDays: number;\n  private readonly securityRetentionDays: number;\n  private readonly maxDirSizeBytes: number;\n  private readonly maxFilesPerCategory: number;\n\n  private readonly buffers = new Map<LogCategory, string[]>();\n  private readonly currentDates = new Map<LogCategory, string>();\n  private readonly sequenceCounters = new Map<LogCategory, number>();\n  private readonly fileSizes = new Map<LogCategory, number>();\n  private initialized = false;\n  private cleanupTimer: ReturnType<typeof setInterval> | null = null;\n\n  constructor(options: FileLogSinkOptions) {\n    this.logDir = options.logDir.startsWith('~')\n      ? path.join(os.homedir(), options.logDir.slice(1))\n      : options.logDir;\n    this.formatter = options.formatter;\n    this.maxFileSize = options.maxFileSize;\n    this.retentionDays = options.retentionDays;\n    this.securityRetentionDays = options.securityRetentionDays;\n    this.maxDirSizeBytes = options.maxDirSizeBytes;\n    this.maxFilesPerCategory = options.maxFilesPerCategory;\n  }\n\n  write(entry: UnifiedLogEntry): void {\n    const formatted = this.formatter.format(entry);\n    let buffer = this.buffers.get(entry.category);\n    if (!buffer) {\n      buffer = [];\n      this.buffers.set(entry.category, buffer);\n    }\n    buffer.push(formatted);\n  }\n\n  async flush(): Promise<void> {\n    const categoriesToFlush: Array<[LogCategory, string]> = [];\n\n    for (const [category, buffer] of this.buffers) {\n      if (buffer.length === 0) continue;\n      const content = buffer.splice(0).join('');\n      categoriesToFlush.push([category, content]);\n    }\n\n    if (categoriesToFlush.length === 0) return;\n\n    try {\n      await this.ensureLogDir();\n\n      for (const [category, content] of categoriesToFlush) {\n        const filePath = await this.resolveFilePath(category, content.length);\n        await fs.appendFile(filePath, content, { mode: 0o600 });\n\n        const currentSize = this.fileSizes.get(category) ?? 0;\n        this.fileSizes.set(category, currentSize + content.length);\n      }\n    } catch (err) {\n      // Best-effort: log to stderr, don't throw\n      process.stderr.write(`[FileLogSink] flush error: ${err}\\n`);\n    }\n  }\n\n  async close(): Promise<void> {\n    await this.flush();\n    if (this.cleanupTimer !== null) {\n      clearInterval(this.cleanupTimer);\n      this.cleanupTimer = null;\n    }\n  }\n\n  async cleanupExpiredFiles(): Promise<void> {\n    try {\n      const files = await fs.readdir(this.logDir);\n      const now = Date.now();\n\n      for (const file of files) {\n        const match = CATEGORY_PATTERN.exec(file);\n        if (!match) continue;\n\n        const category = match[1] as string;\n        const dateStr = match[2];\n        const fileDate = new Date(dateStr + 'T00:00:00Z');\n        if (isNaN(fileDate.getTime())) continue;\n\n        const ageMs = now - fileDate.getTime();\n        const ageDays = ageMs / (1000 * 60 * 60 * 24);\n        const retentionLimit = category === 'security'\n          ? this.securityRetentionDays\n          : this.retentionDays;\n\n        if (ageDays > retentionLimit) {\n          try {\n            await fs.unlink(path.join(this.logDir, file));\n          } catch {\n            // best-effort: skip files that can't be deleted\n          }\n        }\n      }\n    } catch (err) {\n      process.stderr.write(`[FileLogSink] cleanup error: ${err}\\n`);\n    }\n\n    await this.cleanupByFileCount();\n    await this.cleanupByDirSize();\n  }\n\n  startCleanupTimer(): void {\n    if (this.cleanupTimer !== null) return;\n\n    // Run initial cleanup\n    void this.cleanupExpiredFiles();\n\n    // Schedule every 24 hours\n    this.cleanupTimer = setInterval(() => {\n      void this.cleanupExpiredFiles();\n    }, 24 * 60 * 60 * 1000);\n\n    if (this.cleanupTimer && typeof this.cleanupTimer === 'object' && 'unref' in this.cleanupTimer) {\n      this.cleanupTimer.unref();\n    }\n  }\n\n  private async ensureLogDir(): Promise<void> {\n    if (this.initialized) return;\n    await fs.mkdir(this.logDir, { recursive: true, mode: 0o700 });\n    this.initialized = true;\n  }\n\n  /**\n   * Scan the log directory to find the highest existing sequence number for a\n   * given category+date. Used on startup/day-transition to resume from the\n   * correct file instead of always resetting to sequence 0.\n   *\n   * Performance: O(n) over files in the directory, but called at most once per\n   * category per calendar day (on process start or UTC midnight rollover). For\n   * deployments with very large log directories, keep DOLLHOUSE_LOG_MAX_FILES_PER_CATEGORY\n   * set (default 100) so this scan stays fast.\n   *\n   * NOTE: no inter-process locking — if two instances share a log dir they may\n   * both scan and pick the same max seq, then both write to the same file. Each\n   * instance should use its own dedicated log directory. See the troubleshooting\n   * guide (\"Multiple server instances sharing a log directory\") for details.\n   */\n  private async scanMaxSequence(category: LogCategory, today: string): Promise<number> {\n    try {\n      const files = await fs.readdir(this.logDir);\n      let maxSeq = 0;\n      for (const file of files) {\n        const m = ROTATED_FILE_PATTERN.exec(file);\n        if (!m || m[1] !== category || m[2] !== today) continue;\n        const seq = m[3] ? parseInt(m[3], 10) : 0;\n        if (seq > maxSeq) maxSeq = seq;\n      }\n      return maxSeq;\n    } catch {\n      return 0; // log dir doesn't exist yet\n    }\n  }\n\n  private async resolveFilePath(category: LogCategory, contentSize: number): Promise<string> {\n    const today = new Date().toISOString().slice(0, 10);\n    const prevDate = this.currentDates.get(category);\n\n    if (prevDate !== today) {\n      this.currentDates.set(category, today);\n      // Scan for max existing sequence to handle restarts correctly\n      const existingMaxSeq = await this.scanMaxSequence(category, today);\n      this.sequenceCounters.set(category, existingMaxSeq);\n      this.fileSizes.set(category, 0);\n\n      // Stat the highest-sequence file (not just base) to pick up its current size\n      const suffix = existingMaxSeq > 0 ? `.${existingMaxSeq}` : '';\n      const targetPath = path.join(\n        this.logDir,\n        `${category}-${today}${suffix}${this.formatter.fileExtension}`,\n      );\n      try {\n        const stat = await fs.stat(targetPath);\n        this.fileSizes.set(category, stat.size);\n      } catch {\n        // File doesn't exist yet\n      }\n    }\n\n    const currentSize = this.fileSizes.get(category) ?? 0;\n    let seq = this.sequenceCounters.get(category) ?? 0;\n\n    // Check if we need to rotate\n    if (currentSize > 0 && currentSize + contentSize > this.maxFileSize) {\n      seq++;\n      this.sequenceCounters.set(category, seq);\n      this.fileSizes.set(category, 0);\n\n      // Stat the new rotated file to get its size\n      const rotatedPath = path.join(\n        this.logDir,\n        `${category}-${today}.${seq}${this.formatter.fileExtension}`,\n      );\n      try {\n        const stat = await fs.stat(rotatedPath);\n        this.fileSizes.set(category, stat.size);\n      } catch {\n        // File doesn't exist yet\n      }\n    }\n\n    const suffix = seq > 0 ? `.${seq}` : '';\n    return path.join(\n      this.logDir,\n      `${category}-${today}${suffix}${this.formatter.fileExtension}`,\n    );\n  }\n\n  /**\n   * Delete oldest files per category when the file count exceeds\n   * `maxFilesPerCategory`. Sorting is date ASC, then seq ASC within\n   * the same date, so the oldest files are removed first.\n   */\n  private async cleanupByFileCount(): Promise<void> {\n    if (this.maxFilesPerCategory === 0) return;\n    try {\n      const files = await fs.readdir(this.logDir);\n      const byCategory = new Map<string, Array<{ file: string; date: string; seq: number }>>();\n      for (const file of files) {\n        const m = ROTATED_FILE_PATTERN.exec(file);\n        if (!m) continue;\n        const cat = m[1];\n        if (!byCategory.has(cat)) byCategory.set(cat, []);\n        byCategory.get(cat)!.push({ file, date: m[2], seq: m[3] ? parseInt(m[3], 10) : 0 });\n      }\n      for (const [, entries] of byCategory) {\n        if (entries.length <= this.maxFilesPerCategory) continue;\n        // Sort oldest first: date ASC, then seq ASC within same date\n        entries.sort((a, b) => a.date.localeCompare(b.date) || a.seq - b.seq);\n        const toDelete = entries.slice(0, entries.length - this.maxFilesPerCategory);\n        for (const entry of toDelete) {\n          try {\n            await fs.unlink(path.join(this.logDir, entry.file));\n          } catch { /* best-effort */ }\n        }\n      }\n    } catch (err) {\n      process.stderr.write(`[FileLogSink] cleanupByFileCount error: ${err}\\n`);\n    }\n  }\n\n  /**\n   * Delete oldest log files (by mtime) when the total directory size exceeds\n   * `maxDirSizeBytes`. Emits a stderr warning when a security log is deleted\n   * so operators can investigate or increase the cap.\n   */\n  private async cleanupByDirSize(): Promise<void> {\n    if (this.maxDirSizeBytes === 0) return;\n    try {\n      const files = await fs.readdir(this.logDir);\n      const entries: Array<{ file: string; mtime: number; size: number; isSecurity: boolean }> = [];\n      for (const file of files) {\n        if (!ROTATED_FILE_PATTERN.exec(file)) continue;\n        try {\n          const stat = await fs.stat(path.join(this.logDir, file));\n          entries.push({ file, mtime: stat.mtimeMs, size: stat.size, isSecurity: file.startsWith('security-') });\n        } catch { /* best-effort */ }\n      }\n      const totalSize = entries.reduce((sum, e) => sum + e.size, 0);\n      if (totalSize <= this.maxDirSizeBytes) return;\n      // Sort oldest first by mtime\n      entries.sort((a, b) => a.mtime - b.mtime);\n      let remaining = totalSize;\n      for (const entry of entries) {\n        if (remaining <= this.maxDirSizeBytes) break;\n        if (entry.isSecurity) {\n          process.stderr.write(\n            `[FileLogSink] dir-size cap: deleting security log ${entry.file} ` +\n            `(dir=${remaining} > cap=${this.maxDirSizeBytes})\\n`,\n          );\n        }\n        try {\n          await fs.unlink(path.join(this.logDir, entry.file));\n          remaining -= entry.size;\n        } catch { /* best-effort */ }\n      }\n    } catch (err) {\n      process.stderr.write(`[FileLogSink] cleanupByDirSize error: ${err}\\n`);\n    }\n  }\n}\n"]}