@mickdarling/dollhousemcp
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.
226 lines • 29 kB
JavaScript
/**
* Secure Token Manager for DollhouseMCP
*
* Provides secure GitHub token management with validation,
* caching, and error sanitization.
*
* Security: SEC-004 - Token exposure vulnerability protection
*/
import { SecurityError } from '../errors/SecurityError.js';
import { SecurityMonitor } from './securityMonitor.js';
export var TokenScope;
(function (TokenScope) {
TokenScope["READ"] = "read";
TokenScope["WRITE"] = "write";
TokenScope["ADMIN"] = "admin";
})(TokenScope || (TokenScope = {}));
export class SecureTokenManager {
static tokenCache = new Map();
static TOKEN_ROTATION_INTERVAL = 3600000; // 1 hour
// Token patterns to sanitize from errors
static TOKEN_PATTERNS = [
/ghp_[a-zA-Z0-9]{36}/g,
/gho_[a-zA-Z0-9]{36}/g,
/github_pat_[a-zA-Z0-9_]{82}/g,
/Bearer\s+[a-zA-Z0-9_-]+/g,
];
// Valid token formats
static VALID_TOKEN_FORMATS = [
/^ghp_[a-zA-Z0-9]{36}$/, // Personal access token (classic)
/^gho_[a-zA-Z0-9]{36}$/, // OAuth access token
/^github_pat_[a-zA-Z0-9_]{82}$/ // Fine-grained personal access token
];
/**
* Get a secure GitHub token for the specified scope
* @param scope The required permission scope
* @returns The validated token
* @throws SecurityError if token is invalid or missing
*/
static async getSecureGitHubToken(scope) {
try {
// Check cache first
const cached = this.tokenCache.get('github');
if (cached && this.isTokenFresh(cached)) {
await this.validateTokenPermissions(cached.token, scope);
cached.lastUsed = Date.now();
return cached.token;
}
// Get token from environment
const token = process.env.GITHUB_TOKEN;
if (!token) {
throw new SecurityError('GitHub token not found in environment variables', 'TOKEN_NOT_FOUND', 'high', { scope });
}
// Validate format
this.validateTokenFormat(token);
// Validate permissions
await this.validateTokenPermissions(token, scope);
// Cache the token
const metadata = {
token,
scope,
createdAt: Date.now(),
lastUsed: Date.now()
};
this.tokenCache.set('github', metadata);
// Log security event
SecurityMonitor.logSecurityEvent({
type: 'TOKEN_VALIDATION_SUCCESS',
severity: 'LOW',
source: 'SecureTokenManager',
details: 'GitHub token validated successfully',
additionalData: { scope }
});
return token;
}
catch (error) {
// Sanitize error before re-throwing
const sanitizedError = this.sanitizeError(error);
SecurityMonitor.logSecurityEvent({
type: 'TOKEN_VALIDATION_FAILURE',
severity: 'HIGH',
source: 'SecureTokenManager',
details: 'Token validation failed',
additionalData: {
scope,
error: sanitizedError.message
}
});
throw sanitizedError;
}
}
/**
* Validate token format
* @param token The token to validate
* @throws SecurityError if format is invalid
*/
static validateTokenFormat(token) {
const isValid = this.VALID_TOKEN_FORMATS.some(pattern => pattern.test(token));
if (!isValid) {
throw new SecurityError('Invalid GitHub token format', 'INVALID_TOKEN_FORMAT', 'high');
}
// Additional security checks
if (token.length < 40) {
throw new SecurityError('GitHub token too short', 'TOKEN_TOO_SHORT', 'high');
}
if (token.includes(' ') || token.includes('\n') || token.includes('\t')) {
throw new SecurityError('GitHub token contains invalid characters', 'TOKEN_INVALID_CHARS', 'high');
}
}
/**
* Validate token has required permissions
* @param token The token to validate
* @param scope The required scope
* @throws SecurityError if permissions are insufficient
*/
static async validateTokenPermissions(token, scope) {
try {
// Make a test API call to verify token and permissions
const response = await fetch('https://api.github.com/user', {
headers: {
'Authorization': `Bearer ${token}`,
'Accept': 'application/vnd.github.v3+json',
'User-Agent': 'DollhouseMCP/1.2.0'
}
});
if (!response.ok) {
if (response.status === 401) {
throw new SecurityError('GitHub token is invalid or expired', 'TOKEN_INVALID_OR_EXPIRED', 'high');
}
else if (response.status === 403) {
throw new SecurityError('GitHub token lacks required permissions', 'INSUFFICIENT_PERMISSIONS', 'high', { scope });
}
throw new SecurityError(`GitHub API error: ${response.status}`, 'GITHUB_API_ERROR', 'medium');
}
// Check rate limit headers for token validity
const remaining = response.headers.get('x-ratelimit-remaining');
if (remaining && parseInt(remaining) < 100) {
SecurityMonitor.logSecurityEvent({
type: 'RATE_LIMIT_WARNING',
severity: 'MEDIUM',
source: 'SecureTokenManager',
details: 'GitHub API rate limit low',
additionalData: { remaining }
});
}
// For write/admin scopes, verify additional permissions
if (scope === TokenScope.WRITE || scope === TokenScope.ADMIN) {
const scopes = response.headers.get('x-oauth-scopes');
if (!scopes || !this.hasRequiredScopes(scopes, scope)) {
throw new SecurityError(`Token lacks required ${scope} permissions`, 'INSUFFICIENT_SCOPES', 'high', { required: scope, actual: scopes });
}
}
}
catch (error) {
// Network errors should not expose token
if (error instanceof SecurityError) {
throw error;
}
throw new SecurityError('Failed to validate token permissions', 'PERMISSION_VALIDATION_FAILED', 'medium');
}
}
/**
* Check if token has required OAuth scopes
*/
static hasRequiredScopes(scopes, requiredScope) {
const scopeList = scopes.split(',').map(s => s.trim());
switch (requiredScope) {
case TokenScope.READ:
return scopeList.includes('repo') || scopeList.includes('public_repo');
case TokenScope.WRITE:
return scopeList.includes('repo') || scopeList.includes('public_repo');
case TokenScope.ADMIN:
return scopeList.includes('repo') && scopeList.includes('admin:org');
default:
return false;
}
}
/**
* Check if cached token is still fresh
*/
static isTokenFresh(metadata) {
const age = Date.now() - metadata.createdAt;
return age < this.TOKEN_ROTATION_INTERVAL;
}
/**
* Sanitize error messages to remove sensitive data
* @param error The error to sanitize
* @returns A safe error object
*/
static sanitizeError(error) {
let message = error?.message || 'Unknown error';
let stack = error?.stack || '';
// Sanitize all token patterns
for (const pattern of this.TOKEN_PATTERNS) {
message = message.replace(pattern, '[REDACTED]');
stack = stack.replace(pattern, '[REDACTED]');
}
// Remove any environment variable values
message = message.replace(/GITHUB_TOKEN=\S+/g, 'GITHUB_TOKEN=[REDACTED]');
stack = stack.replace(/GITHUB_TOKEN=\S+/g, 'GITHUB_TOKEN=[REDACTED]');
const sanitizedError = new Error(message);
sanitizedError.stack = stack;
return sanitizedError;
}
/**
* Clear cached tokens (useful for testing or forced rotation)
*/
static clearCache() {
this.tokenCache.clear();
SecurityMonitor.logSecurityEvent({
type: 'TOKEN_CACHE_CLEARED',
severity: 'LOW',
source: 'SecureTokenManager',
details: 'Token cache cleared'
});
}
/**
* Get token cache statistics (for monitoring)
*/
static getCacheStats() {
return {
size: this.tokenCache.size,
tokens: Array.from(this.tokenCache.keys())
};
}
}
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"tokenManager.js","sourceRoot":"","sources":["../../src/security/tokenManager.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,EAAE,aAAa,EAAE,MAAM,4BAA4B,CAAC;AAC3D,OAAO,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAC;AAEvD,MAAM,CAAN,IAAY,UAIX;AAJD,WAAY,UAAU;IACpB,2BAAa,CAAA;IACb,6BAAe,CAAA;IACf,6BAAe,CAAA;AACjB,CAAC,EAJW,UAAU,KAAV,UAAU,QAIrB;AASD,MAAM,OAAO,kBAAkB;IACrB,MAAM,CAAC,UAAU,GAA+B,IAAI,GAAG,EAAE,CAAC;IAC1D,MAAM,CAAU,uBAAuB,GAAG,OAAO,CAAC,CAAC,SAAS;IAEpE,yCAAyC;IACjC,MAAM,CAAU,cAAc,GAAG;QACvC,sBAAsB;QACtB,sBAAsB;QACtB,8BAA8B;QAC9B,0BAA0B;KAC3B,CAAC;IAEF,sBAAsB;IACd,MAAM,CAAU,mBAAmB,GAAG;QAC5C,uBAAuB,EAAO,kCAAkC;QAChE,uBAAuB,EAAO,qBAAqB;QACnD,+BAA+B,CAAC,qCAAqC;KACtE,CAAC;IAEF;;;;;OAKG;IACH,MAAM,CAAC,KAAK,CAAC,oBAAoB,CAAC,KAAiB;QACjD,IAAI,CAAC;YACH,oBAAoB;YACpB,MAAM,MAAM,GAAG,IAAI,CAAC,UAAU,CAAC,GAAG,CAAC,QAAQ,CAAC,CAAC;YAC7C,IAAI,MAAM,IAAI,IAAI,CAAC,YAAY,CAAC,MAAM,CAAC,EAAE,CAAC;gBACxC,MAAM,IAAI,CAAC,wBAAwB,CAAC,MAAM,CAAC,KAAK,EAAE,KAAK,CAAC,CAAC;gBACzD,MAAM,CAAC,QAAQ,GAAG,IAAI,CAAC,GAAG,EAAE,CAAC;gBAC7B,OAAO,MAAM,CAAC,KAAK,CAAC;YACtB,CAAC;YAED,6BAA6B;YAC7B,MAAM,KAAK,GAAG,OAAO,CAAC,GAAG,CAAC,YAAY,CAAC;YACvC,IAAI,CAAC,KAAK,EAAE,CAAC;gBACX,MAAM,IAAI,aAAa,CACrB,iDAAiD,EACjD,iBAAiB,EACjB,MAAM,EACN,EAAE,KAAK,EAAE,CACV,CAAC;YACJ,CAAC;YAED,kBAAkB;YAClB,IAAI,CAAC,mBAAmB,CAAC,KAAK,CAAC,CAAC;YAEhC,uBAAuB;YACvB,MAAM,IAAI,CAAC,wBAAwB,CAAC,KAAK,EAAE,KAAK,CAAC,CAAC;YAElD,kBAAkB;YAClB,MAAM,QAAQ,GAAkB;gBAC9B,KAAK;gBACL,KAAK;gBACL,SAAS,EAAE,IAAI,CAAC,GAAG,EAAE;gBACrB,QAAQ,EAAE,IAAI,CAAC,GAAG,EAAE;aACrB,CAAC;YACF,IAAI,CAAC,UAAU,CAAC,GAAG,CAAC,QAAQ,EAAE,QAAQ,CAAC,CAAC;YAExC,qBAAqB;YACrB,eAAe,CAAC,gBAAgB,CAAC;gBAC/B,IAAI,EAAE,0BAA0B;gBAChC,QAAQ,EAAE,KAAK;gBACf,MAAM,EAAE,oBAAoB;gBAC5B,OAAO,EAAE,qCAAqC;gBAC9C,cAAc,EAAE,EAAE,KAAK,EAAE;aAC1B,CAAC,CAAC;YAEH,OAAO,KAAK,CAAC;QACf,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,oCAAoC;YACpC,MAAM,cAAc,GAAG,IAAI,CAAC,aAAa,CAAC,KAAK,CAAC,CAAC;YAEjD,eAAe,CAAC,gBAAgB,CAAC;gBAC/B,IAAI,EAAE,0BAA0B;gBAChC,QAAQ,EAAE,MAAM;gBAChB,MAAM,EAAE,oBAAoB;gBAC5B,OAAO,EAAE,yBAAyB;gBAClC,cAAc,EAAE;oBACd,KAAK;oBACL,KAAK,EAAE,cAAc,CAAC,OAAO;iBAC9B;aACF,CAAC,CAAC;YAEH,MAAM,cAAc,CAAC;QACvB,CAAC;IACH,CAAC;IAED;;;;OAIG;IACK,MAAM,CAAC,mBAAmB,CAAC,KAAa;QAC9C,MAAM,OAAO,GAAG,IAAI,CAAC,mBAAmB,CAAC,IAAI,CAAC,OAAO,CAAC,EAAE,CAAC,OAAO,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC;QAE9E,IAAI,CAAC,OAAO,EAAE,CAAC;YACb,MAAM,IAAI,aAAa,CACrB,6BAA6B,EAC7B,sBAAsB,EACtB,MAAM,CACP,CAAC;QACJ,CAAC;QAED,6BAA6B;QAC7B,IAAI,KAAK,CAAC,MAAM,GAAG,EAAE,EAAE,CAAC;YACtB,MAAM,IAAI,aAAa,CACrB,wBAAwB,EACxB,iBAAiB,EACjB,MAAM,CACP,CAAC;QACJ,CAAC;QAED,IAAI,KAAK,CAAC,QAAQ,CAAC,GAAG,CAAC,IAAI,KAAK,CAAC,QAAQ,CAAC,IAAI,CAAC,IAAI,KAAK,CAAC,QAAQ,CAAC,IAAI,CAAC,EAAE,CAAC;YACxE,MAAM,IAAI,aAAa,CACrB,0CAA0C,EAC1C,qBAAqB,EACrB,MAAM,CACP,CAAC;QACJ,CAAC;IACH,CAAC;IAED;;;;;OAKG;IACK,MAAM,CAAC,KAAK,CAAC,wBAAwB,CAAC,KAAa,EAAE,KAAiB;QAC5E,IAAI,CAAC;YACH,uDAAuD;YACvD,MAAM,QAAQ,GAAG,MAAM,KAAK,CAAC,6BAA6B,EAAE;gBAC1D,OAAO,EAAE;oBACP,eAAe,EAAE,UAAU,KAAK,EAAE;oBAClC,QAAQ,EAAE,gCAAgC;oBAC1C,YAAY,EAAE,oBAAoB;iBACnC;aACF,CAAC,CAAC;YAEH,IAAI,CAAC,QAAQ,CAAC,EAAE,EAAE,CAAC;gBACjB,IAAI,QAAQ,CAAC,MAAM,KAAK,GAAG,EAAE,CAAC;oBAC5B,MAAM,IAAI,aAAa,CACrB,oCAAoC,EACpC,0BAA0B,EAC1B,MAAM,CACP,CAAC;gBACJ,CAAC;qBAAM,IAAI,QAAQ,CAAC,MAAM,KAAK,GAAG,EAAE,CAAC;oBACnC,MAAM,IAAI,aAAa,CACrB,yCAAyC,EACzC,0BAA0B,EAC1B,MAAM,EACN,EAAE,KAAK,EAAE,CACV,CAAC;gBACJ,CAAC;gBACD,MAAM,IAAI,aAAa,CACrB,qBAAqB,QAAQ,CAAC,MAAM,EAAE,EACtC,kBAAkB,EAClB,QAAQ,CACT,CAAC;YACJ,CAAC;YAED,8CAA8C;YAC9C,MAAM,SAAS,GAAG,QAAQ,CAAC,OAAO,CAAC,GAAG,CAAC,uBAAuB,CAAC,CAAC;YAChE,IAAI,SAAS,IAAI,QAAQ,CAAC,SAAS,CAAC,GAAG,GAAG,EAAE,CAAC;gBAC3C,eAAe,CAAC,gBAAgB,CAAC;oBAC/B,IAAI,EAAE,oBAAoB;oBAC1B,QAAQ,EAAE,QAAQ;oBAClB,MAAM,EAAE,oBAAoB;oBAC5B,OAAO,EAAE,2BAA2B;oBACpC,cAAc,EAAE,EAAE,SAAS,EAAE;iBAC9B,CAAC,CAAC;YACL,CAAC;YAED,wDAAwD;YACxD,IAAI,KAAK,KAAK,UAAU,CAAC,KAAK,IAAI,KAAK,KAAK,UAAU,CAAC,KAAK,EAAE,CAAC;gBAC7D,MAAM,MAAM,GAAG,QAAQ,CAAC,OAAO,CAAC,GAAG,CAAC,gBAAgB,CAAC,CAAC;gBACtD,IAAI,CAAC,MAAM,IAAI,CAAC,IAAI,CAAC,iBAAiB,CAAC,MAAM,EAAE,KAAK,CAAC,EAAE,CAAC;oBACtD,MAAM,IAAI,aAAa,CACrB,wBAAwB,KAAK,cAAc,EAC3C,qBAAqB,EACrB,MAAM,EACN,EAAE,QAAQ,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,CACpC,CAAC;gBACJ,CAAC;YACH,CAAC;QACH,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,yCAAyC;YACzC,IAAI,KAAK,YAAY,aAAa,EAAE,CAAC;gBACnC,MAAM,KAAK,CAAC;YACd,CAAC;YACD,MAAM,IAAI,aAAa,CACrB,sCAAsC,EACtC,8BAA8B,EAC9B,QAAQ,CACT,CAAC;QACJ,CAAC;IACH,CAAC;IAED;;OAEG;IACK,MAAM,CAAC,iBAAiB,CAAC,MAAc,EAAE,aAAyB;QACxE,MAAM,SAAS,GAAG,MAAM,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,IAAI,EAAE,CAAC,CAAC;QAEvD,QAAQ,aAAa,EAAE,CAAC;YACtB,KAAK,UAAU,CAAC,IAAI;gBAClB,OAAO,SAAS,CAAC,QAAQ,CAAC,MAAM,CAAC,IAAI,SAAS,CAAC,QAAQ,CAAC,aAAa,CAAC,CAAC;YACzE,KAAK,UAAU,CAAC,KAAK;gBACnB,OAAO,SAAS,CAAC,QAAQ,CAAC,MAAM,CAAC,IAAI,SAAS,CAAC,QAAQ,CAAC,aAAa,CAAC,CAAC;YACzE,KAAK,UAAU,CAAC,KAAK;gBACnB,OAAO,SAAS,CAAC,QAAQ,CAAC,MAAM,CAAC,IAAI,SAAS,CAAC,QAAQ,CAAC,WAAW,CAAC,CAAC;YACvE;gBACE,OAAO,KAAK,CAAC;QACjB,CAAC;IACH,CAAC;IAED;;OAEG;IACK,MAAM,CAAC,YAAY,CAAC,QAAuB;QACjD,MAAM,GAAG,GAAG,IAAI,CAAC,GAAG,EAAE,GAAG,QAAQ,CAAC,SAAS,CAAC;QAC5C,OAAO,GAAG,GAAG,IAAI,CAAC,uBAAuB,CAAC;IAC5C,CAAC;IAED;;;;OAIG;IACK,MAAM,CAAC,aAAa,CAAC,KAAU;QACrC,IAAI,OAAO,GAAG,KAAK,EAAE,OAAO,IAAI,eAAe,CAAC;QAChD,IAAI,KAAK,GAAG,KAAK,EAAE,KAAK,IAAI,EAAE,CAAC;QAE/B,8BAA8B;QAC9B,KAAK,MAAM,OAAO,IAAI,IAAI,CAAC,cAAc,EAAE,CAAC;YAC1C,OAAO,GAAG,OAAO,CAAC,OAAO,CAAC,OAAO,EAAE,YAAY,CAAC,CAAC;YACjD,KAAK,GAAG,KAAK,CAAC,OAAO,CAAC,OAAO,EAAE,YAAY,CAAC,CAAC;QAC/C,CAAC;QAED,yCAAyC;QACzC,OAAO,GAAG,OAAO,CAAC,OAAO,CAAC,mBAAmB,EAAE,yBAAyB,CAAC,CAAC;QAC1E,KAAK,GAAG,KAAK,CAAC,OAAO,CAAC,mBAAmB,EAAE,yBAAyB,CAAC,CAAC;QAEtE,MAAM,cAAc,GAAG,IAAI,KAAK,CAAC,OAAO,CAAC,CAAC;QAC1C,cAAc,CAAC,KAAK,GAAG,KAAK,CAAC;QAE7B,OAAO,cAAc,CAAC;IACxB,CAAC;IAED;;OAEG;IACH,MAAM,CAAC,UAAU;QACf,IAAI,CAAC,UAAU,CAAC,KAAK,EAAE,CAAC;QAExB,eAAe,CAAC,gBAAgB,CAAC;YAC/B,IAAI,EAAE,qBAAqB;YAC3B,QAAQ,EAAE,KAAK;YACf,MAAM,EAAE,oBAAoB;YAC5B,OAAO,EAAE,qBAAqB;SAC/B,CAAC,CAAC;IACL,CAAC;IAED;;OAEG;IACH,MAAM,CAAC,aAAa;QAClB,OAAO;YACL,IAAI,EAAE,IAAI,CAAC,UAAU,CAAC,IAAI;YAC1B,MAAM,EAAE,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,UAAU,CAAC,IAAI,EAAE,CAAC;SAC3C,CAAC;IACJ,CAAC","sourcesContent":["/**\n * Secure Token Manager for DollhouseMCP\n * \n * Provides secure GitHub token management with validation,\n * caching, and error sanitization.\n * \n * Security: SEC-004 - Token exposure vulnerability protection\n */\n\nimport { SecurityError } from '../errors/SecurityError.js';\nimport { SecurityMonitor } from './securityMonitor.js';\n\nexport enum TokenScope {\n  READ = 'read',\n  WRITE = 'write',\n  ADMIN = 'admin'\n}\n\ninterface TokenMetadata {\n  token: string;\n  scope: TokenScope;\n  createdAt: number;\n  lastUsed: number;\n}\n\nexport class SecureTokenManager {\n  private static tokenCache: Map<string, TokenMetadata> = new Map();\n  private static readonly TOKEN_ROTATION_INTERVAL = 3600000; // 1 hour\n  \n  // Token patterns to sanitize from errors\n  private static readonly TOKEN_PATTERNS = [\n    /ghp_[a-zA-Z0-9]{36}/g,\n    /gho_[a-zA-Z0-9]{36}/g,\n    /github_pat_[a-zA-Z0-9_]{82}/g,\n    /Bearer\\s+[a-zA-Z0-9_-]+/g,\n  ];\n\n  // Valid token formats\n  private static readonly VALID_TOKEN_FORMATS = [\n    /^ghp_[a-zA-Z0-9]{36}$/,      // Personal access token (classic)\n    /^gho_[a-zA-Z0-9]{36}$/,      // OAuth access token\n    /^github_pat_[a-zA-Z0-9_]{82}$/ // Fine-grained personal access token\n  ];\n\n  /**\n   * Get a secure GitHub token for the specified scope\n   * @param scope The required permission scope\n   * @returns The validated token\n   * @throws SecurityError if token is invalid or missing\n   */\n  static async getSecureGitHubToken(scope: TokenScope): Promise<string> {\n    try {\n      // Check cache first\n      const cached = this.tokenCache.get('github');\n      if (cached && this.isTokenFresh(cached)) {\n        await this.validateTokenPermissions(cached.token, scope);\n        cached.lastUsed = Date.now();\n        return cached.token;\n      }\n\n      // Get token from environment\n      const token = process.env.GITHUB_TOKEN;\n      if (!token) {\n        throw new SecurityError(\n          'GitHub token not found in environment variables',\n          'TOKEN_NOT_FOUND',\n          'high',\n          { scope }\n        );\n      }\n\n      // Validate format\n      this.validateTokenFormat(token);\n\n      // Validate permissions\n      await this.validateTokenPermissions(token, scope);\n\n      // Cache the token\n      const metadata: TokenMetadata = {\n        token,\n        scope,\n        createdAt: Date.now(),\n        lastUsed: Date.now()\n      };\n      this.tokenCache.set('github', metadata);\n\n      // Log security event\n      SecurityMonitor.logSecurityEvent({\n        type: 'TOKEN_VALIDATION_SUCCESS',\n        severity: 'LOW',\n        source: 'SecureTokenManager',\n        details: 'GitHub token validated successfully',\n        additionalData: { scope }\n      });\n\n      return token;\n    } catch (error) {\n      // Sanitize error before re-throwing\n      const sanitizedError = this.sanitizeError(error);\n      \n      SecurityMonitor.logSecurityEvent({\n        type: 'TOKEN_VALIDATION_FAILURE',\n        severity: 'HIGH',\n        source: 'SecureTokenManager',\n        details: 'Token validation failed',\n        additionalData: { \n          scope,\n          error: sanitizedError.message \n        }\n      });\n\n      throw sanitizedError;\n    }\n  }\n\n  /**\n   * Validate token format\n   * @param token The token to validate\n   * @throws SecurityError if format is invalid\n   */\n  private static validateTokenFormat(token: string): void {\n    const isValid = this.VALID_TOKEN_FORMATS.some(pattern => pattern.test(token));\n    \n    if (!isValid) {\n      throw new SecurityError(\n        'Invalid GitHub token format',\n        'INVALID_TOKEN_FORMAT',\n        'high'\n      );\n    }\n\n    // Additional security checks\n    if (token.length < 40) {\n      throw new SecurityError(\n        'GitHub token too short',\n        'TOKEN_TOO_SHORT',\n        'high'\n      );\n    }\n\n    if (token.includes(' ') || token.includes('\\n') || token.includes('\\t')) {\n      throw new SecurityError(\n        'GitHub token contains invalid characters',\n        'TOKEN_INVALID_CHARS',\n        'high'\n      );\n    }\n  }\n\n  /**\n   * Validate token has required permissions\n   * @param token The token to validate\n   * @param scope The required scope\n   * @throws SecurityError if permissions are insufficient\n   */\n  private static async validateTokenPermissions(token: string, scope: TokenScope): Promise<void> {\n    try {\n      // Make a test API call to verify token and permissions\n      const response = await fetch('https://api.github.com/user', {\n        headers: {\n          'Authorization': `Bearer ${token}`,\n          'Accept': 'application/vnd.github.v3+json',\n          'User-Agent': 'DollhouseMCP/1.2.0'\n        }\n      });\n\n      if (!response.ok) {\n        if (response.status === 401) {\n          throw new SecurityError(\n            'GitHub token is invalid or expired',\n            'TOKEN_INVALID_OR_EXPIRED',\n            'high'\n          );\n        } else if (response.status === 403) {\n          throw new SecurityError(\n            'GitHub token lacks required permissions',\n            'INSUFFICIENT_PERMISSIONS',\n            'high',\n            { scope }\n          );\n        }\n        throw new SecurityError(\n          `GitHub API error: ${response.status}`,\n          'GITHUB_API_ERROR',\n          'medium'\n        );\n      }\n\n      // Check rate limit headers for token validity\n      const remaining = response.headers.get('x-ratelimit-remaining');\n      if (remaining && parseInt(remaining) < 100) {\n        SecurityMonitor.logSecurityEvent({\n          type: 'RATE_LIMIT_WARNING',\n          severity: 'MEDIUM',\n          source: 'SecureTokenManager',\n          details: 'GitHub API rate limit low',\n          additionalData: { remaining }\n        });\n      }\n\n      // For write/admin scopes, verify additional permissions\n      if (scope === TokenScope.WRITE || scope === TokenScope.ADMIN) {\n        const scopes = response.headers.get('x-oauth-scopes');\n        if (!scopes || !this.hasRequiredScopes(scopes, scope)) {\n          throw new SecurityError(\n            `Token lacks required ${scope} permissions`,\n            'INSUFFICIENT_SCOPES',\n            'high',\n            { required: scope, actual: scopes }\n          );\n        }\n      }\n    } catch (error) {\n      // Network errors should not expose token\n      if (error instanceof SecurityError) {\n        throw error;\n      }\n      throw new SecurityError(\n        'Failed to validate token permissions',\n        'PERMISSION_VALIDATION_FAILED',\n        'medium'\n      );\n    }\n  }\n\n  /**\n   * Check if token has required OAuth scopes\n   */\n  private static hasRequiredScopes(scopes: string, requiredScope: TokenScope): boolean {\n    const scopeList = scopes.split(',').map(s => s.trim());\n    \n    switch (requiredScope) {\n      case TokenScope.READ:\n        return scopeList.includes('repo') || scopeList.includes('public_repo');\n      case TokenScope.WRITE:\n        return scopeList.includes('repo') || scopeList.includes('public_repo');\n      case TokenScope.ADMIN:\n        return scopeList.includes('repo') && scopeList.includes('admin:org');\n      default:\n        return false;\n    }\n  }\n\n  /**\n   * Check if cached token is still fresh\n   */\n  private static isTokenFresh(metadata: TokenMetadata): boolean {\n    const age = Date.now() - metadata.createdAt;\n    return age < this.TOKEN_ROTATION_INTERVAL;\n  }\n\n  /**\n   * Sanitize error messages to remove sensitive data\n   * @param error The error to sanitize\n   * @returns A safe error object\n   */\n  private static sanitizeError(error: any): Error {\n    let message = error?.message || 'Unknown error';\n    let stack = error?.stack || '';\n\n    // Sanitize all token patterns\n    for (const pattern of this.TOKEN_PATTERNS) {\n      message = message.replace(pattern, '[REDACTED]');\n      stack = stack.replace(pattern, '[REDACTED]');\n    }\n\n    // Remove any environment variable values\n    message = message.replace(/GITHUB_TOKEN=\\S+/g, 'GITHUB_TOKEN=[REDACTED]');\n    stack = stack.replace(/GITHUB_TOKEN=\\S+/g, 'GITHUB_TOKEN=[REDACTED]');\n\n    const sanitizedError = new Error(message);\n    sanitizedError.stack = stack;\n    \n    return sanitizedError;\n  }\n\n  /**\n   * Clear cached tokens (useful for testing or forced rotation)\n   */\n  static clearCache(): void {\n    this.tokenCache.clear();\n    \n    SecurityMonitor.logSecurityEvent({\n      type: 'TOKEN_CACHE_CLEARED',\n      severity: 'LOW',\n      source: 'SecureTokenManager',\n      details: 'Token cache cleared'\n    });\n  }\n\n  /**\n   * Get token cache statistics (for monitoring)\n   */\n  static getCacheStats(): { size: number; tokens: string[] } {\n    return {\n      size: this.tokenCache.size,\n      tokens: Array.from(this.tokenCache.keys())\n    };\n  }\n}"]}