@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.
189 lines • 21.5 kB
JavaScript
/**
* RateLimiter - Implements rate limiting for API calls to prevent abuse
*
* Features:
* - Token bucket algorithm for flexible rate limiting
* - Configurable limits per time window
* - Memory-efficient implementation
* - Thread-safe for concurrent requests
*/
export class RateLimiter {
tokens;
lastRefill;
lastRequest;
maxTokens;
refillRate;
minDelay;
constructor(config) {
if (config.maxRequests <= 0) {
throw new Error('maxRequests must be positive');
}
if (config.windowMs <= 0) {
throw new Error('windowMs must be positive');
}
this.maxTokens = config.maxRequests;
this.tokens = this.maxTokens;
this.refillRate = this.maxTokens / config.windowMs;
// Validate refill rate to prevent division by zero
if (this.refillRate <= 0 || !Number.isFinite(this.refillRate)) {
throw new Error('Invalid configuration: refill rate must be positive and finite');
}
this.lastRefill = Date.now();
this.lastRequest = 0;
this.minDelay = config.minDelayMs || 0;
}
/**
* Check if a request is allowed under the rate limit
* @returns Status object indicating if request is allowed
*/
checkLimit() {
const now = Date.now();
// Refill tokens based on time elapsed
this.refillTokens(now);
// Check minimum delay between requests
if (this.minDelay > 0 && this.lastRequest > 0) {
const timeSinceLastRequest = now - this.lastRequest;
if (timeSinceLastRequest < this.minDelay) {
const retryAfterMs = Math.max(1, this.minDelay - timeSinceLastRequest);
return {
allowed: false,
retryAfterMs,
remainingTokens: Math.floor(this.tokens),
resetTime: new Date(now + retryAfterMs)
};
}
}
// Check if we have tokens available
if (this.tokens < 1) {
// Calculate when the next token will be available
const tokensNeeded = 1 - this.tokens;
const rawMs = tokensNeeded / this.refillRate;
// Clamp to safe bounds: at least 1ms, at most 1 hour, and always finite
const retryAfterMs = Math.max(1, Math.min(3_600_000, Number.isFinite(rawMs) ? Math.ceil(rawMs) : 60_000));
return {
allowed: false,
retryAfterMs,
remainingTokens: 0,
resetTime: new Date(now + retryAfterMs)
};
}
// Request is allowed
return {
allowed: true,
remainingTokens: Math.floor(this.tokens),
resetTime: this.getResetTime()
};
}
/**
* Consume a token for an allowed request
* Should be called after checkLimit() returns allowed: true
*/
consumeToken() {
const now = Date.now();
this.refillTokens(now);
if (this.tokens >= 1) {
this.tokens -= 1;
this.lastRequest = now;
}
}
/**
* Get current rate limit status without consuming a token
*/
getStatus() {
const now = Date.now();
this.refillTokens(now);
return {
allowed: this.tokens >= 1,
remainingTokens: Math.floor(this.tokens),
resetTime: this.getResetTime()
};
}
/**
* Reset the rate limiter to full capacity
* Useful for testing or manual intervention
*/
reset() {
this.tokens = this.maxTokens;
this.lastRefill = Date.now();
this.lastRequest = 0;
}
/**
* Refill tokens based on time elapsed
*/
refillTokens(now) {
const timeSinceLastRefill = now - this.lastRefill;
const tokensToAdd = timeSinceLastRefill * this.refillRate;
this.tokens = Math.min(this.maxTokens, this.tokens + tokensToAdd);
this.lastRefill = now;
}
/**
* Calculate when the rate limit window will reset
*/
getResetTime() {
const now = Date.now();
const tokensToFull = this.maxTokens - this.tokens;
const msUntilFull = tokensToFull / this.refillRate;
return new Date(now + msUntilFull);
}
/**
* Get human-readable rate limit information
*/
toString() {
const status = this.getStatus();
return `RateLimit: ${status.remainingTokens}/${this.maxTokens} tokens, ` +
`resets at ${status.resetTime.toISOString()}`;
}
}
/**
* Factory function to create common rate limiters
*/
export class RateLimiterFactory {
/**
* GitHub API rate limiter (60 requests per hour for unauthenticated)
*/
static createGitHubLimiter() {
return new RateLimiter({
maxRequests: 60,
windowMs: 60 * 60 * 1000, // 1 hour
minDelayMs: 1000 // 1 second minimum between requests
});
}
/**
* Conservative rate limiter for update checks
* Allows 10 checks per hour with 30 second minimum delay
*/
static createUpdateCheckLimiter() {
return new RateLimiter({
maxRequests: 10,
windowMs: 60 * 60 * 1000, // 1 hour
minDelayMs: 30 * 1000 // 30 seconds between checks
});
}
/**
* Strict rate limiter for sensitive operations
* Allows 5 requests per hour with 1 minute minimum delay
*/
static createStrictLimiter() {
return new RateLimiter({
maxRequests: 5,
windowMs: 60 * 60 * 1000, // 1 hour
minDelayMs: 60 * 1000 // 1 minute between requests
});
}
/**
* Rate limiter for permission_prompt evaluations (Issue #625 Phase 4).
* 100 requests per 60-second window — high throughput for rapid tool calls.
*/
static createPermissionPromptLimiter(maxRequests = 100, windowMs = 60_000) {
return new RateLimiter({ maxRequests, windowMs });
}
/**
* Rate limiter for CLI approval record creation (Issue #625 Phase 4).
* Default 20 requests per 60-second window — prevents approval request flooding.
* Configurable via parameters (MCPAQLHandler reads from env vars).
*/
static createCliApprovalLimiter(maxRequests = 20, windowMs = 60_000) {
return new RateLimiter({ maxRequests, windowMs });
}
}
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"RateLimiter.js","sourceRoot":"","sources":["../../src/utils/RateLimiter.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * RateLimiter - Implements rate limiting for API calls to prevent abuse\n * \n * Features:\n * - Token bucket algorithm for flexible rate limiting\n * - Configurable limits per time window\n * - Memory-efficient implementation\n * - Thread-safe for concurrent requests\n */\n\nexport interface RateLimiterConfig {\n  maxRequests: number;      // Maximum requests allowed\n  windowMs: number;         // Time window in milliseconds\n  minDelayMs?: number;      // Minimum delay between requests (optional)\n}\n\nexport interface RateLimitStatus {\n  allowed: boolean;\n  retryAfterMs?: number;\n  remainingTokens: number;\n  resetTime: Date;\n}\n\nexport class RateLimiter {\n  private tokens: number;\n  private lastRefill: number;\n  private lastRequest: number;\n  private readonly maxTokens: number;\n  private readonly refillRate: number;\n  private readonly minDelay: number;\n\n  constructor(config: RateLimiterConfig) {\n    if (config.maxRequests <= 0) {\n      throw new Error('maxRequests must be positive');\n    }\n    if (config.windowMs <= 0) {\n      throw new Error('windowMs must be positive');\n    }\n\n    this.maxTokens = config.maxRequests;\n    this.tokens = this.maxTokens;\n    this.refillRate = this.maxTokens / config.windowMs;\n    \n    // Validate refill rate to prevent division by zero\n    if (this.refillRate <= 0 || !Number.isFinite(this.refillRate)) {\n      throw new Error('Invalid configuration: refill rate must be positive and finite');\n    }\n    \n    this.lastRefill = Date.now();\n    this.lastRequest = 0;\n    this.minDelay = config.minDelayMs || 0;\n  }\n\n  /**\n   * Check if a request is allowed under the rate limit\n   * @returns Status object indicating if request is allowed\n   */\n  checkLimit(): RateLimitStatus {\n    const now = Date.now();\n    \n    // Refill tokens based on time elapsed\n    this.refillTokens(now);\n\n    // Check minimum delay between requests\n    if (this.minDelay > 0 && this.lastRequest > 0) {\n      const timeSinceLastRequest = now - this.lastRequest;\n      if (timeSinceLastRequest < this.minDelay) {\n        const retryAfterMs = Math.max(1, this.minDelay - timeSinceLastRequest);\n        return {\n          allowed: false,\n          retryAfterMs,\n          remainingTokens: Math.floor(this.tokens),\n          resetTime: new Date(now + retryAfterMs)\n        };\n      }\n    }\n\n    // Check if we have tokens available\n    if (this.tokens < 1) {\n      // Calculate when the next token will be available\n      const tokensNeeded = 1 - this.tokens;\n      const rawMs = tokensNeeded / this.refillRate;\n      // Clamp to safe bounds: at least 1ms, at most 1 hour, and always finite\n      const retryAfterMs = Math.max(1, Math.min(3_600_000, Number.isFinite(rawMs) ? Math.ceil(rawMs) : 60_000));\n\n      return {\n        allowed: false,\n        retryAfterMs,\n        remainingTokens: 0,\n        resetTime: new Date(now + retryAfterMs)\n      };\n    }\n\n    // Request is allowed\n    return {\n      allowed: true,\n      remainingTokens: Math.floor(this.tokens),\n      resetTime: this.getResetTime()\n    };\n  }\n\n  /**\n   * Consume a token for an allowed request\n   * Should be called after checkLimit() returns allowed: true\n   */\n  consumeToken(): void {\n    const now = Date.now();\n    this.refillTokens(now);\n    \n    if (this.tokens >= 1) {\n      this.tokens -= 1;\n      this.lastRequest = now;\n    }\n  }\n\n  /**\n   * Get current rate limit status without consuming a token\n   */\n  getStatus(): RateLimitStatus {\n    const now = Date.now();\n    this.refillTokens(now);\n\n    return {\n      allowed: this.tokens >= 1,\n      remainingTokens: Math.floor(this.tokens),\n      resetTime: this.getResetTime()\n    };\n  }\n\n  /**\n   * Reset the rate limiter to full capacity\n   * Useful for testing or manual intervention\n   */\n  reset(): void {\n    this.tokens = this.maxTokens;\n    this.lastRefill = Date.now();\n    this.lastRequest = 0;\n  }\n\n  /**\n   * Refill tokens based on time elapsed\n   */\n  private refillTokens(now: number): void {\n    const timeSinceLastRefill = now - this.lastRefill;\n    const tokensToAdd = timeSinceLastRefill * this.refillRate;\n    \n    this.tokens = Math.min(this.maxTokens, this.tokens + tokensToAdd);\n    this.lastRefill = now;\n  }\n\n  /**\n   * Calculate when the rate limit window will reset\n   */\n  private getResetTime(): Date {\n    const now = Date.now();\n    const tokensToFull = this.maxTokens - this.tokens;\n    const msUntilFull = tokensToFull / this.refillRate;\n    return new Date(now + msUntilFull);\n  }\n\n  /**\n   * Get human-readable rate limit information\n   */\n  toString(): string {\n    const status = this.getStatus();\n    return `RateLimit: ${status.remainingTokens}/${this.maxTokens} tokens, ` +\n           `resets at ${status.resetTime.toISOString()}`;\n  }\n}\n\n/**\n * Factory function to create common rate limiters\n */\nexport class RateLimiterFactory {\n  /**\n   * GitHub API rate limiter (60 requests per hour for unauthenticated)\n   */\n  static createGitHubLimiter(): RateLimiter {\n    return new RateLimiter({\n      maxRequests: 60,\n      windowMs: 60 * 60 * 1000, // 1 hour\n      minDelayMs: 1000 // 1 second minimum between requests\n    });\n  }\n\n  /**\n   * Conservative rate limiter for update checks\n   * Allows 10 checks per hour with 30 second minimum delay\n   */\n  static createUpdateCheckLimiter(): RateLimiter {\n    return new RateLimiter({\n      maxRequests: 10,\n      windowMs: 60 * 60 * 1000, // 1 hour\n      minDelayMs: 30 * 1000 // 30 seconds between checks\n    });\n  }\n\n  /**\n   * Strict rate limiter for sensitive operations\n   * Allows 5 requests per hour with 1 minute minimum delay\n   */\n  static createStrictLimiter(): RateLimiter {\n    return new RateLimiter({\n      maxRequests: 5,\n      windowMs: 60 * 60 * 1000, // 1 hour\n      minDelayMs: 60 * 1000 // 1 minute between requests\n    });\n  }\n\n  /**\n   * Rate limiter for permission_prompt evaluations (Issue #625 Phase 4).\n   * 100 requests per 60-second window — high throughput for rapid tool calls.\n   */\n  static createPermissionPromptLimiter(maxRequests = 100, windowMs = 60_000): RateLimiter {\n    return new RateLimiter({ maxRequests, windowMs });\n  }\n\n  /**\n   * Rate limiter for CLI approval record creation (Issue #625 Phase 4).\n   * Default 20 requests per 60-second window — prevents approval request flooding.\n   * Configurable via parameters (MCPAQLHandler reads from env vars).\n   */\n  static createCliApprovalLimiter(maxRequests = 20, windowMs = 60_000): RateLimiter {\n    return new RateLimiter({ maxRequests, windowMs });\n  }\n}"]}