@dollhousemcp/mcp-server 1.3.0

package/dist/src/security/tokenManager.d.ts

@@ -0,0 +1,59 @@
+/**
+ * Secure GitHub token management and validation
+ */
+export interface TokenScopes {
+    required: string[];
+    optional?: string[];
+}
+export interface TokenValidationResult {
+    isValid: boolean;
+    scopes?: string[];
+    rateLimit?: {
+        remaining: number;
+        resetTime: Date;
+    };
+    error?: string;
+}
+/**
+ * Secure GitHub token manager with validation and protection
+ */
+export declare class TokenManager {
+    private static readonly GITHUB_TOKEN_PATTERNS;
+    /**
+     * Validate GitHub token format
+     */
+    static validateTokenFormat(token: string): boolean;
+    /**
+     * Get GitHub token from environment with validation
+     */
+    static getGitHubToken(): string | null;
+    /**
+     * Redact token for safe logging
+     */
+    static redactToken(token: string): string;
+    /**
+     * Get token type from format
+     */
+    static getTokenType(token: string): string;
+    /**
+     * Get safe token prefix for logging
+     */
+    static getTokenPrefix(token: string): string;
+    /**
+     * Validate token scopes via GitHub API
+     */
+    static validateTokenScopes(token: string, requiredScopes: TokenScopes): Promise<TokenValidationResult>;
+    /**
+     * Create safe error message without token exposure
+     */
+    static createSafeErrorMessage(error: string, token?: string): string;
+    /**
+     * Get minimum required scopes for different operations
+     */
+    static getRequiredScopes(operation: 'read' | 'write' | 'marketplace' | 'gist'): TokenScopes;
+    /**
+     * Check if token has sufficient permissions for operation
+     */
+    static ensureTokenPermissions(operation: 'read' | 'write' | 'marketplace' | 'gist'): Promise<TokenValidationResult>;
+}
+//# sourceMappingURL=tokenManager.d.ts.map

package/dist/src/security/tokenManager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tokenManager.d.ts","sourceRoot":"","sources":["../../../src/security/tokenManager.ts"],"names":[],"mappings":"AAAA;;GAEG;AAIH,MAAM,WAAW,WAAW;IAC1B,QAAQ,EAAE,MAAM,EAAE,CAAC;IACnB,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAC;CACrB;AAED,MAAM,WAAW,qBAAqB;IACpC,OAAO,EAAE,OAAO,CAAC;IACjB,MAAM,CAAC,EAAE,MAAM,EAAE,CAAC;IAClB,SAAS,CAAC,EAAE;QACV,SAAS,EAAE,MAAM,CAAC;QAClB,SAAS,EAAE,IAAI,CAAC;KACjB,CAAC;IACF,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAED;;GAEG;AACH,qBAAa,YAAY;IACvB,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,qBAAqB,CAK3C;IAEF;;OAEG;IACH,MAAM,CAAC,mBAAmB,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO;IAWlD;;OAEG;IACH,MAAM,CAAC,cAAc,IAAI,MAAM,GAAG,IAAI;IAwBtC;;OAEG;IACH,MAAM,CAAC,WAAW,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM;IAQzC;;OAEG;IACH,MAAM,CAAC,YAAY,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM;IAgB1C;;OAEG;IACH,MAAM,CAAC,cAAc,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM;IAO5C;;OAEG;WACU,mBAAmB,CAC9B,KAAK,EAAE,MAAM,EACb,cAAc,EAAE,WAAW,GAC1B,OAAO,CAAC,qBAAqB,CAAC;IAoFjC;;OAEG;IACH,MAAM,CAAC,sBAAsB,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,MAAM,GAAG,MAAM;IAgBpE;;OAEG;IACH,MAAM,CAAC,iBAAiB,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,GAAG,aAAa,GAAG,MAAM,GAAG,WAAW;IAiC3F;;OAEG;WACU,sBAAsB,CACjC,SAAS,EAAE,MAAM,GAAG,OAAO,GAAG,aAAa,GAAG,MAAM,GACnD,OAAO,CAAC,qBAAqB,CAAC;CAalC"}

package/dist/src/security/tokenManager.js

@@ -0,0 +1,216 @@
+/**
+ * Secure GitHub token management and validation
+ */
+import { logger } from '../utils/logger.js';
+/**
+ * Secure GitHub token manager with validation and protection
+ */
+export class TokenManager {
+    static GITHUB_TOKEN_PATTERNS = {
+        PERSONAL_ACCESS_TOKEN: /^ghp_[A-Za-z0-9_]{36,}$/,
+        INSTALLATION_TOKEN: /^ghs_[A-Za-z0-9_]{36,}$/,
+        USER_ACCESS_TOKEN: /^ghu_[A-Za-z0-9_]{36,}$/,
+        REFRESH_TOKEN: /^ghr_[A-Za-z0-9_]{36,}$/
+    };
+    /**
+     * Validate GitHub token format
+     */
+    static validateTokenFormat(token) {
+        if (!token || typeof token !== 'string') {
+            return false;
+        }
+        // Check against all known GitHub token patterns
+        return Object.values(this.GITHUB_TOKEN_PATTERNS).some(pattern => pattern.test(token));
+    }
+    /**
+     * Get GitHub token from environment with validation
+     */
+    static getGitHubToken() {
+        const token = process.env.GITHUB_TOKEN;
+        if (!token) {
+            logger.debug('No GitHub token found in environment');
+            return null;
+        }
+        if (!this.validateTokenFormat(token)) {
+            logger.warn('Invalid GitHub token format detected', {
+                tokenPrefix: this.getTokenPrefix(token),
+                length: token.length
+            });
+            return null;
+        }
+        logger.debug('Valid GitHub token found', {
+            tokenType: this.getTokenType(token),
+            tokenPrefix: this.getTokenPrefix(token)
+        });
+        return token;
+    }
+    /**
+     * Redact token for safe logging
+     */
+    static redactToken(token) {
+        if (!token || token.length < 8) {
+            return '[REDACTED]';
+        }
+        return token.substring(0, 4) + '...' + token.substring(token.length - 4);
+    }
+    /**
+     * Get token type from format
+     */
+    static getTokenType(token) {
+        if (this.GITHUB_TOKEN_PATTERNS.PERSONAL_ACCESS_TOKEN.test(token)) {
+            return 'Personal Access Token';
+        }
+        if (this.GITHUB_TOKEN_PATTERNS.INSTALLATION_TOKEN.test(token)) {
+            return 'Installation Token';
+        }
+        if (this.GITHUB_TOKEN_PATTERNS.USER_ACCESS_TOKEN.test(token)) {
+            return 'User Access Token';
+        }
+        if (this.GITHUB_TOKEN_PATTERNS.REFRESH_TOKEN.test(token)) {
+            return 'Refresh Token';
+        }
+        return 'Unknown';
+    }
+    /**
+     * Get safe token prefix for logging
+     */
+    static getTokenPrefix(token) {
+        if (!token || token.length < 4) {
+            return '[INVALID]';
+        }
+        return token.substring(0, 4) + '...';
+    }
+    /**
+     * Validate token scopes via GitHub API
+     */
+    static async validateTokenScopes(token, requiredScopes) {
+        try {
+            // Make a test API call to check token validity and scopes
+            const response = await fetch('https://api.github.com/user', {
+                headers: {
+                    'Authorization': `Bearer ${token}`,
+                    'Accept': 'application/vnd.github.v3+json',
+                    'User-Agent': 'DollhouseMCP/1.0'
+                }
+            });
+            const rateLimitRemaining = parseInt(response.headers.get('x-ratelimit-remaining') || '0');
+            const rateLimitReset = parseInt(response.headers.get('x-ratelimit-reset') || '0');
+            if (!response.ok) {
+                const error = `GitHub API error: ${response.status} ${response.statusText}`;
+                logger.warn('Token validation failed', {
+                    status: response.status,
+                    tokenPrefix: this.getTokenPrefix(token)
+                });
+                return {
+                    isValid: false,
+                    error: error
+                };
+            }
+            // Extract scopes from response headers
+            const scopesHeader = response.headers.get('x-oauth-scopes') || '';
+            const tokenScopes = scopesHeader.split(',').map(s => s.trim()).filter(s => s);
+            // Check if required scopes are present
+            const hasRequiredScopes = requiredScopes.required.every(scope => tokenScopes.includes(scope));
+            if (!hasRequiredScopes) {
+                const missingScopes = requiredScopes.required.filter(scope => !tokenScopes.includes(scope));
+                logger.warn('Token missing required scopes', {
+                    tokenPrefix: this.getTokenPrefix(token),
+                    missingScopes: missingScopes,
+                    currentScopes: tokenScopes
+                });
+                return {
+                    isValid: false,
+                    scopes: tokenScopes,
+                    error: `Missing required scopes: ${missingScopes.join(', ')}`
+                };
+            }
+            logger.info('Token validation successful', {
+                tokenType: this.getTokenType(token),
+                tokenPrefix: this.getTokenPrefix(token),
+                scopes: tokenScopes,
+                rateLimitRemaining: rateLimitRemaining
+            });
+            return {
+                isValid: true,
+                scopes: tokenScopes,
+                rateLimit: {
+                    remaining: rateLimitRemaining,
+                    resetTime: new Date(rateLimitReset * 1000)
+                }
+            };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+            logger.error('Token validation error', {
+                error: errorMessage,
+                tokenPrefix: this.getTokenPrefix(token)
+            });
+            return {
+                isValid: false,
+                error: `Validation error: ${errorMessage}`
+            };
+        }
+    }
+    /**
+     * Create safe error message without token exposure
+     */
+    static createSafeErrorMessage(error, token) {
+        // Remove any potential token data from error messages
+        let safeMessage = error
+            .replace(/ghp_[A-Za-z0-9_]{36,}/g, '[REDACTED_PAT]')
+            .replace(/ghs_[A-Za-z0-9_]{36,}/g, '[REDACTED_INSTALL]')
+            .replace(/ghu_[A-Za-z0-9_]{36,}/g, '[REDACTED_USER]')
+            .replace(/ghr_[A-Za-z0-9_]{36,}/g, '[REDACTED_REFRESH]');
+        if (token) {
+            const tokenPrefix = this.getTokenPrefix(token);
+            safeMessage += ` (Token: ${tokenPrefix})`;
+        }
+        return safeMessage;
+    }
+    /**
+     * Get minimum required scopes for different operations
+     */
+    static getRequiredScopes(operation) {
+        switch (operation) {
+            case 'read':
+                return {
+                    required: ['repo'],
+                    optional: ['user:email']
+                };
+            case 'write':
+                return {
+                    required: ['repo'],
+                    optional: ['user:email']
+                };
+            case 'marketplace':
+                return {
+                    required: ['repo'],
+                    optional: ['user:email']
+                };
+            case 'gist':
+                return {
+                    required: ['gist'],
+                    optional: ['user:email']
+                };
+            default:
+                return {
+                    required: ['repo']
+                };
+        }
+    }
+    /**
+     * Check if token has sufficient permissions for operation
+     */
+    static async ensureTokenPermissions(operation) {
+        const token = this.getGitHubToken();
+        if (!token) {
+            return {
+                isValid: false,
+                error: 'No GitHub token available'
+            };
+        }
+        const requiredScopes = this.getRequiredScopes(operation);
+        return this.validateTokenScopes(token, requiredScopes);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"tokenManager.js","sourceRoot":"","sources":["../../../src/security/tokenManager.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAE,MAAM,EAAE,MAAM,oBAAoB,CAAC;AAiB5C;;GAEG;AACH,MAAM,OAAO,YAAY;IACf,MAAM,CAAU,qBAAqB,GAAG;QAC9C,qBAAqB,EAAE,yBAAyB;QAChD,kBAAkB,EAAE,yBAAyB;QAC7C,iBAAiB,EAAE,yBAAyB;QAC5C,aAAa,EAAE,yBAAyB;KACzC,CAAC;IAEF;;OAEG;IACH,MAAM,CAAC,mBAAmB,CAAC,KAAa;QACtC,IAAI,CAAC,KAAK,IAAI,OAAO,KAAK,KAAK,QAAQ,EAAE,CAAC;YACxC,OAAO,KAAK,CAAC;QACf,CAAC;QAED,gDAAgD;QAChD,OAAO,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,qBAAqB,CAAC,CAAC,IAAI,CAAC,OAAO,CAAC,EAAE,CAC9D,OAAO,CAAC,IAAI,CAAC,KAAK,CAAC,CACpB,CAAC;IACJ,CAAC;IAED;;OAEG;IACH,MAAM,CAAC,cAAc;QACnB,MAAM,KAAK,GAAG,OAAO,CAAC,GAAG,CAAC,YAAY,CAAC;QAEvC,IAAI,CAAC,KAAK,EAAE,CAAC;YACX,MAAM,CAAC,KAAK,CAAC,sCAAsC,CAAC,CAAC;YACrD,OAAO,IAAI,CAAC;QACd,CAAC;QAED,IAAI,CAAC,IAAI,CAAC,mBAAmB,CAAC,KAAK,CAAC,EAAE,CAAC;YACrC,MAAM,CAAC,IAAI,CAAC,sCAAsC,EAAE;gBAClD,WAAW,EAAE,IAAI,CAAC,cAAc,CAAC,KAAK,CAAC;gBACvC,MAAM,EAAE,KAAK,CAAC,MAAM;aACrB,CAAC,CAAC;YACH,OAAO,IAAI,CAAC;QACd,CAAC;QAED,MAAM,CAAC,KAAK,CAAC,0BAA0B,EAAE;YACvC,SAAS,EAAE,IAAI,CAAC,YAAY,CAAC,KAAK,CAAC;YACnC,WAAW,EAAE,IAAI,CAAC,cAAc,CAAC,KAAK,CAAC;SACxC,CAAC,CAAC;QAEH,OAAO,KAAK,CAAC;IACf,CAAC;IAED;;OAEG;IACH,MAAM,CAAC,WAAW,CAAC,KAAa;QAC9B,IAAI,CAAC,KAAK,IAAI,KAAK,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;YAC/B,OAAO,YAAY,CAAC;QACtB,CAAC;QAED,OAAO,KAAK,CAAC,SAAS,CAAC,CAAC,EAAE,CAAC,CAAC,GAAG,KAAK,GAAG,KAAK,CAAC,SAAS,CAAC,KAAK,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC;IAC3E,CAAC;IAED;;OAEG;IACH,MAAM,CAAC,YAAY,CAAC,KAAa;QAC/B,IAAI,IAAI,CAAC,qBAAqB,CAAC,qBAAqB,CAAC,IAAI,CAAC,KAAK,CAAC,EAAE,CAAC;YACjE,OAAO,uBAAuB,CAAC;QACjC,CAAC;QACD,IAAI,IAAI,CAAC,qBAAqB,CAAC,kBAAkB,CAAC,IAAI,CAAC,KAAK,CAAC,EAAE,CAAC;YAC9D,OAAO,oBAAoB,CAAC;QAC9B,CAAC;QACD,IAAI,IAAI,CAAC,qBAAqB,CAAC,iBAAiB,CAAC,IAAI,CAAC,KAAK,CAAC,EAAE,CAAC;YAC7D,OAAO,mBAAmB,CAAC;QAC7B,CAAC;QACD,IAAI,IAAI,CAAC,qBAAqB,CAAC,aAAa,CAAC,IAAI,CAAC,KAAK,CAAC,EAAE,CAAC;YACzD,OAAO,eAAe,CAAC;QACzB,CAAC;QACD,OAAO,SAAS,CAAC;IACnB,CAAC;IAED;;OAEG;IACH,MAAM,CAAC,cAAc,CAAC,KAAa;QACjC,IAAI,CAAC,KAAK,IAAI,KAAK,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;YAC/B,OAAO,WAAW,CAAC;QACrB,CAAC;QACD,OAAO,KAAK,CAAC,SAAS,CAAC,CAAC,EAAE,CAAC,CAAC,GAAG,KAAK,CAAC;IACvC,CAAC;IAED;;OAEG;IACH,MAAM,CAAC,KAAK,CAAC,mBAAmB,CAC9B,KAAa,EACb,cAA2B;QAE3B,IAAI,CAAC;YACH,0DAA0D;YAC1D,MAAM,QAAQ,GAAG,MAAM,KAAK,CAAC,6BAA6B,EAAE;gBAC1D,OAAO,EAAE;oBACP,eAAe,EAAE,UAAU,KAAK,EAAE;oBAClC,QAAQ,EAAE,gCAAgC;oBAC1C,YAAY,EAAE,kBAAkB;iBACjC;aACF,CAAC,CAAC;YAEH,MAAM,kBAAkB,GAAG,QAAQ,CAAC,QAAQ,CAAC,OAAO,CAAC,GAAG,CAAC,uBAAuB,CAAC,IAAI,GAAG,CAAC,CAAC;YAC1F,MAAM,cAAc,GAAG,QAAQ,CAAC,QAAQ,CAAC,OAAO,CAAC,GAAG,CAAC,mBAAmB,CAAC,IAAI,GAAG,CAAC,CAAC;YAElF,IAAI,CAAC,QAAQ,CAAC,EAAE,EAAE,CAAC;gBACjB,MAAM,KAAK,GAAG,qBAAqB,QAAQ,CAAC,MAAM,IAAI,QAAQ,CAAC,UAAU,EAAE,CAAC;gBAC5E,MAAM,CAAC,IAAI,CAAC,yBAAyB,EAAE;oBACrC,MAAM,EAAE,QAAQ,CAAC,MAAM;oBACvB,WAAW,EAAE,IAAI,CAAC,cAAc,CAAC,KAAK,CAAC;iBACxC,CAAC,CAAC;gBAEH,OAAO;oBACL,OAAO,EAAE,KAAK;oBACd,KAAK,EAAE,KAAK;iBACb,CAAC;YACJ,CAAC;YAED,uCAAuC;YACvC,MAAM,YAAY,GAAG,QAAQ,CAAC,OAAO,CAAC,GAAG,CAAC,gBAAgB,CAAC,IAAI,EAAE,CAAC;YAClE,MAAM,WAAW,GAAG,YAAY,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,IAAI,EAAE,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC;YAE9E,uCAAuC;YACvC,MAAM,iBAAiB,GAAG,cAAc,CAAC,QAAQ,CAAC,KAAK,CAAC,KAAK,CAAC,EAAE,CAC9D,WAAW,CAAC,QAAQ,CAAC,KAAK,CAAC,CAC5B,CAAC;YAEF,IAAI,CAAC,iBAAiB,EAAE,CAAC;gBACvB,MAAM,aAAa,GAAG,cAAc,CAAC,QAAQ,CAAC,MAAM,CAAC,KAAK,CAAC,EAAE,CAC3D,CAAC,WAAW,CAAC,QAAQ,CAAC,KAAK,CAAC,CAC7B,CAAC;gBAEF,MAAM,CAAC,IAAI,CAAC,+BAA+B,EAAE;oBAC3C,WAAW,EAAE,IAAI,CAAC,cAAc,CAAC,KAAK,CAAC;oBACvC,aAAa,EAAE,aAAa;oBAC5B,aAAa,EAAE,WAAW;iBAC3B,CAAC,CAAC;gBAEH,OAAO;oBACL,OAAO,EAAE,KAAK;oBACd,MAAM,EAAE,WAAW;oBACnB,KAAK,EAAE,4BAA4B,aAAa,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE;iBAC9D,CAAC;YACJ,CAAC;YAED,MAAM,CAAC,IAAI,CAAC,6BAA6B,EAAE;gBACzC,SAAS,EAAE,IAAI,CAAC,YAAY,CAAC,KAAK,CAAC;gBACnC,WAAW,EAAE,IAAI,CAAC,cAAc,CAAC,KAAK,CAAC;gBACvC,MAAM,EAAE,WAAW;gBACnB,kBAAkB,EAAE,kBAAkB;aACvC,CAAC,CAAC;YAEH,OAAO;gBACL,OAAO,EAAE,IAAI;gBACb,MAAM,EAAE,WAAW;gBACnB,SAAS,EAAE;oBACT,SAAS,EAAE,kBAAkB;oBAC7B,SAAS,EAAE,IAAI,IAAI,CAAC,cAAc,GAAG,IAAI,CAAC;iBAC3C;aACF,CAAC;QAEJ,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,MAAM,YAAY,GAAG,KAAK,YAAY,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,eAAe,CAAC;YAC9E,MAAM,CAAC,KAAK,CAAC,wBAAwB,EAAE;gBACrC,KAAK,EAAE,YAAY;gBACnB,WAAW,EAAE,IAAI,CAAC,cAAc,CAAC,KAAK,CAAC;aACxC,CAAC,CAAC;YAEH,OAAO;gBACL,OAAO,EAAE,KAAK;gBACd,KAAK,EAAE,qBAAqB,YAAY,EAAE;aAC3C,CAAC;QACJ,CAAC;IACH,CAAC;IAED;;OAEG;IACH,MAAM,CAAC,sBAAsB,CAAC,KAAa,EAAE,KAAc;QACzD,sDAAsD;QACtD,IAAI,WAAW,GAAG,KAAK;aACpB,OAAO,CAAC,wBAAwB,EAAE,gBAAgB,CAAC;aACnD,OAAO,CAAC,wBAAwB,EAAE,oBAAoB,CAAC;aACvD,OAAO,CAAC,wBAAwB,EAAE,iBAAiB,CAAC;aACpD,OAAO,CAAC,wBAAwB,EAAE,oBAAoB,CAAC,CAAC;QAE3D,IAAI,KAAK,EAAE,CAAC;YACV,MAAM,WAAW,GAAG,IAAI,CAAC,cAAc,CAAC,KAAK,CAAC,CAAC;YAC/C,WAAW,IAAI,YAAY,WAAW,GAAG,CAAC;QAC5C,CAAC;QAED,OAAO,WAAW,CAAC;IACrB,CAAC;IAED;;OAEG;IACH,MAAM,CAAC,iBAAiB,CAAC,SAAoD;QAC3E,QAAQ,SAAS,EAAE,CAAC;YAClB,KAAK,MAAM;gBACT,OAAO;oBACL,QAAQ,EAAE,CAAC,MAAM,CAAC;oBAClB,QAAQ,EAAE,CAAC,YAAY,CAAC;iBACzB,CAAC;YAEJ,KAAK,OAAO;gBACV,OAAO;oBACL,QAAQ,EAAE,CAAC,MAAM,CAAC;oBAClB,QAAQ,EAAE,CAAC,YAAY,CAAC;iBACzB,CAAC;YAEJ,KAAK,aAAa;gBAChB,OAAO;oBACL,QAAQ,EAAE,CAAC,MAAM,CAAC;oBAClB,QAAQ,EAAE,CAAC,YAAY,CAAC;iBACzB,CAAC;YAEJ,KAAK,MAAM;gBACT,OAAO;oBACL,QAAQ,EAAE,CAAC,MAAM,CAAC;oBAClB,QAAQ,EAAE,CAAC,YAAY,CAAC;iBACzB,CAAC;YAEJ;gBACE,OAAO;oBACL,QAAQ,EAAE,CAAC,MAAM,CAAC;iBACnB,CAAC;QACN,CAAC;IACH,CAAC;IAED;;OAEG;IACH,MAAM,CAAC,KAAK,CAAC,sBAAsB,CACjC,SAAoD;QAEpD,MAAM,KAAK,GAAG,IAAI,CAAC,cAAc,EAAE,CAAC;QAEpC,IAAI,CAAC,KAAK,EAAE,CAAC;YACX,OAAO;gBACL,OAAO,EAAE,KAAK;gBACd,KAAK,EAAE,2BAA2B;aACnC,CAAC;QACJ,CAAC;QAED,MAAM,cAAc,GAAG,IAAI,CAAC,iBAAiB,CAAC,SAAS,CAAC,CAAC;QACzD,OAAO,IAAI,CAAC,mBAAmB,CAAC,KAAK,EAAE,cAAc,CAAC,CAAC;IACzD,CAAC","sourcesContent":["/**\n * Secure GitHub token management and validation\n */\n\nimport { logger } from '../utils/logger.js';\n\nexport interface TokenScopes {\n  required: string[];\n  optional?: string[];\n}\n\nexport interface TokenValidationResult {\n  isValid: boolean;\n  scopes?: string[];\n  rateLimit?: {\n    remaining: number;\n    resetTime: Date;\n  };\n  error?: string;\n}\n\n/**\n * Secure GitHub token manager with validation and protection\n */\nexport class TokenManager {\n  private static readonly GITHUB_TOKEN_PATTERNS = {\n    PERSONAL_ACCESS_TOKEN: /^ghp_[A-Za-z0-9_]{36,}$/,\n    INSTALLATION_TOKEN: /^ghs_[A-Za-z0-9_]{36,}$/,\n    USER_ACCESS_TOKEN: /^ghu_[A-Za-z0-9_]{36,}$/,\n    REFRESH_TOKEN: /^ghr_[A-Za-z0-9_]{36,}$/\n  };\n\n  /**\n   * Validate GitHub token format\n   */\n  static validateTokenFormat(token: string): boolean {\n    if (!token || typeof token !== 'string') {\n      return false;\n    }\n\n    // Check against all known GitHub token patterns\n    return Object.values(this.GITHUB_TOKEN_PATTERNS).some(pattern => \n      pattern.test(token)\n    );\n  }\n\n  /**\n   * Get GitHub token from environment with validation\n   */\n  static getGitHubToken(): string | null {\n    const token = process.env.GITHUB_TOKEN;\n    \n    if (!token) {\n      logger.debug('No GitHub token found in environment');\n      return null;\n    }\n\n    if (!this.validateTokenFormat(token)) {\n      logger.warn('Invalid GitHub token format detected', {\n        tokenPrefix: this.getTokenPrefix(token),\n        length: token.length\n      });\n      return null;\n    }\n\n    logger.debug('Valid GitHub token found', {\n      tokenType: this.getTokenType(token),\n      tokenPrefix: this.getTokenPrefix(token)\n    });\n\n    return token;\n  }\n\n  /**\n   * Redact token for safe logging\n   */\n  static redactToken(token: string): string {\n    if (!token || token.length < 8) {\n      return '[REDACTED]';\n    }\n    \n    return token.substring(0, 4) + '...' + token.substring(token.length - 4);\n  }\n\n  /**\n   * Get token type from format\n   */\n  static getTokenType(token: string): string {\n    if (this.GITHUB_TOKEN_PATTERNS.PERSONAL_ACCESS_TOKEN.test(token)) {\n      return 'Personal Access Token';\n    }\n    if (this.GITHUB_TOKEN_PATTERNS.INSTALLATION_TOKEN.test(token)) {\n      return 'Installation Token';\n    }\n    if (this.GITHUB_TOKEN_PATTERNS.USER_ACCESS_TOKEN.test(token)) {\n      return 'User Access Token';\n    }\n    if (this.GITHUB_TOKEN_PATTERNS.REFRESH_TOKEN.test(token)) {\n      return 'Refresh Token';\n    }\n    return 'Unknown';\n  }\n\n  /**\n   * Get safe token prefix for logging\n   */\n  static getTokenPrefix(token: string): string {\n    if (!token || token.length < 4) {\n      return '[INVALID]';\n    }\n    return token.substring(0, 4) + '...';\n  }\n\n  /**\n   * Validate token scopes via GitHub API\n   */\n  static async validateTokenScopes(\n    token: string, \n    requiredScopes: TokenScopes\n  ): Promise<TokenValidationResult> {\n    try {\n      // Make a test API call to check token validity and scopes\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.0'\n        }\n      });\n\n      const rateLimitRemaining = parseInt(response.headers.get('x-ratelimit-remaining') || '0');\n      const rateLimitReset = parseInt(response.headers.get('x-ratelimit-reset') || '0');\n\n      if (!response.ok) {\n        const error = `GitHub API error: ${response.status} ${response.statusText}`;\n        logger.warn('Token validation failed', {\n          status: response.status,\n          tokenPrefix: this.getTokenPrefix(token)\n        });\n        \n        return {\n          isValid: false,\n          error: error\n        };\n      }\n\n      // Extract scopes from response headers\n      const scopesHeader = response.headers.get('x-oauth-scopes') || '';\n      const tokenScopes = scopesHeader.split(',').map(s => s.trim()).filter(s => s);\n\n      // Check if required scopes are present\n      const hasRequiredScopes = requiredScopes.required.every(scope => \n        tokenScopes.includes(scope)\n      );\n\n      if (!hasRequiredScopes) {\n        const missingScopes = requiredScopes.required.filter(scope => \n          !tokenScopes.includes(scope)\n        );\n        \n        logger.warn('Token missing required scopes', {\n          tokenPrefix: this.getTokenPrefix(token),\n          missingScopes: missingScopes,\n          currentScopes: tokenScopes\n        });\n\n        return {\n          isValid: false,\n          scopes: tokenScopes,\n          error: `Missing required scopes: ${missingScopes.join(', ')}`\n        };\n      }\n\n      logger.info('Token validation successful', {\n        tokenType: this.getTokenType(token),\n        tokenPrefix: this.getTokenPrefix(token),\n        scopes: tokenScopes,\n        rateLimitRemaining: rateLimitRemaining\n      });\n\n      return {\n        isValid: true,\n        scopes: tokenScopes,\n        rateLimit: {\n          remaining: rateLimitRemaining,\n          resetTime: new Date(rateLimitReset * 1000)\n        }\n      };\n\n    } catch (error) {\n      const errorMessage = error instanceof Error ? error.message : 'Unknown error';\n      logger.error('Token validation error', {\n        error: errorMessage,\n        tokenPrefix: this.getTokenPrefix(token)\n      });\n\n      return {\n        isValid: false,\n        error: `Validation error: ${errorMessage}`\n      };\n    }\n  }\n\n  /**\n   * Create safe error message without token exposure\n   */\n  static createSafeErrorMessage(error: string, token?: string): string {\n    // Remove any potential token data from error messages\n    let safeMessage = error\n      .replace(/ghp_[A-Za-z0-9_]{36,}/g, '[REDACTED_PAT]')\n      .replace(/ghs_[A-Za-z0-9_]{36,}/g, '[REDACTED_INSTALL]')\n      .replace(/ghu_[A-Za-z0-9_]{36,}/g, '[REDACTED_USER]')\n      .replace(/ghr_[A-Za-z0-9_]{36,}/g, '[REDACTED_REFRESH]');\n\n    if (token) {\n      const tokenPrefix = this.getTokenPrefix(token);\n      safeMessage += ` (Token: ${tokenPrefix})`;\n    }\n\n    return safeMessage;\n  }\n\n  /**\n   * Get minimum required scopes for different operations\n   */\n  static getRequiredScopes(operation: 'read' | 'write' | 'marketplace' | 'gist'): TokenScopes {\n    switch (operation) {\n      case 'read':\n        return {\n          required: ['repo'],\n          optional: ['user:email']\n        };\n      \n      case 'write':\n        return {\n          required: ['repo'],\n          optional: ['user:email']\n        };\n      \n      case 'marketplace':\n        return {\n          required: ['repo'],\n          optional: ['user:email']\n        };\n      \n      case 'gist':\n        return {\n          required: ['gist'],\n          optional: ['user:email']\n        };\n      \n      default:\n        return {\n          required: ['repo']\n        };\n    }\n  }\n\n  /**\n   * Check if token has sufficient permissions for operation\n   */\n  static async ensureTokenPermissions(\n    operation: 'read' | 'write' | 'marketplace' | 'gist'\n  ): Promise<TokenValidationResult> {\n    const token = this.getGitHubToken();\n    \n    if (!token) {\n      return {\n        isValid: false,\n        error: 'No GitHub token available'\n      };\n    }\n\n    const requiredScopes = this.getRequiredScopes(operation);\n    return this.validateTokenScopes(token, requiredScopes);\n  }\n}"]}

package/dist/src/security/yamlValidator.d.ts

@@ -0,0 +1,20 @@
+export declare class YamlValidator {
+    private static purifyWindow;
+    private static purify;
+    static parsePersonaMetadataSafely(yamlContent: string): any;
+    private static sanitizeMetadata;
+    /**
+     * Initialize DOMPurify instance if not already initialized
+     */
+    private static initializePurify;
+    /**
+     * Sanitize string input using DOMPurify to prevent XSS attacks
+     * This replaces the regex-based approach with a more robust solution
+     */
+    private static sanitizeString;
+    /**
+     * Reset static DOMPurify cache (useful for long-running processes)
+     */
+    static resetCache(): void;
+}
+//# sourceMappingURL=yamlValidator.d.ts.map

package/dist/src/security/yamlValidator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"yamlValidator.d.ts","sourceRoot":"","sources":["../../../src/security/yamlValidator.ts"],"names":[],"mappings":"AA0BA,qBAAa,aAAa;IAExB,OAAO,CAAC,MAAM,CAAC,YAAY,CAAa;IACxC,OAAO,CAAC,MAAM,CAAC,MAAM,CAAkC;IAEvD,MAAM,CAAC,0BAA0B,CAAC,WAAW,EAAE,MAAM,GAAG,GAAG;IA6C3D,OAAO,CAAC,MAAM,CAAC,gBAAgB;IAmB/B;;OAEG;IACH,OAAO,CAAC,MAAM,CAAC,gBAAgB;IAQ/B;;;OAGG;IACH,OAAO,CAAC,MAAM,CAAC,cAAc;IA4C7B;;OAEG;WACW,UAAU,IAAI,IAAI;CAIjC"}

package/dist/src/security/yamlValidator.js

@@ -0,0 +1,138 @@
+import yaml from 'js-yaml';
+import { z } from 'zod';
+import { logger } from '../utils/logger.js';
+import DOMPurify from 'dompurify';
+import { JSDOM } from 'jsdom';
+const PersonaMetadataSchema = z.object({
+    name: z.string().min(1).max(100),
+    description: z.string().min(1).max(1000),
+    unique_id: z.string().optional(),
+    author: z.string().max(50).optional(),
+    triggers: z.array(z.string().max(50)).max(20).optional(),
+    version: z.string().regex(/^\d+\.\d+\.\d+$/).optional(),
+    category: z.enum(['creative', 'professional', 'educational', 'gaming', 'personal']).optional(),
+    age_rating: z.enum(['all', '13+', '18+']).optional(),
+    content_flags: z.array(z.string()).optional(),
+    ai_generated: z.boolean().optional(),
+    generation_method: z.string().max(50).optional(),
+    price: z.string().max(20).optional(),
+    license: z.string().max(100).optional(),
+    created_date: z.string().optional()
+});
+export class YamlValidator {
+    // Static cache for DOMPurify to improve performance
+    static purifyWindow = null;
+    static purify = null;
+    static parsePersonaMetadataSafely(yamlContent) {
+        if (!yamlContent || typeof yamlContent !== 'string') {
+            throw new Error('YAML content must be a non-empty string');
+        }
+        // Size check
+        if (yamlContent.length > 50000) { // 50KB
+            throw new Error('YAML content too large');
+        }
+        // Check for dangerous tags
+        if (yamlContent.includes('!!js/') || yamlContent.includes('!!python/')) {
+            throw new Error('Dangerous YAML tags detected');
+        }
+        // Check for excessive anchors/aliases (YAML bomb protection)
+        const anchorCount = (yamlContent.match(/&\w+/g) || []).length;
+        const aliasCount = (yamlContent.match(/\*\w+/g) || []).length;
+        if (anchorCount > 10 || aliasCount > 20) {
+            throw new Error('Potential YAML bomb detected');
+        }
+        try {
+            // Use safe load with restricted schema
+            const rawData = yaml.load(yamlContent, {
+                schema: yaml.CORE_SCHEMA, // No functions, only basic types
+                onWarning: (warning) => {
+                    logger.warn('YAML parsing warning:', warning);
+                }
+            });
+            // Validate against schema
+            const validatedData = PersonaMetadataSchema.parse(rawData);
+            // Additional sanitization
+            return this.sanitizeMetadata(validatedData);
+        }
+        catch (error) {
+            if (error instanceof Error && error.name === 'YAMLException') {
+                throw new Error(`Invalid YAML syntax: ${error.message}`);
+            }
+            throw new Error(`Invalid persona metadata: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    static sanitizeMetadata(data) {
+        const sanitized = { ...data };
+        // Sanitize string fields
+        const stringFields = ['name', 'description', 'author', 'unique_id'];
+        for (const field of stringFields) {
+            if (sanitized[field]) {
+                sanitized[field] = this.sanitizeString(sanitized[field]);
+            }
+        }
+        // Sanitize array fields
+        if (sanitized.triggers) {
+            sanitized.triggers = sanitized.triggers.map((t) => this.sanitizeString(t));
+        }
+        return sanitized;
+    }
+    /**
+     * Initialize DOMPurify instance if not already initialized
+     */
+    static initializePurify() {
+        if (!this.purifyWindow || !this.purify) {
+            const dom = new JSDOM('');
+            this.purifyWindow = dom.window;
+            this.purify = DOMPurify(this.purifyWindow);
+        }
+    }
+    /**
+     * Sanitize string input using DOMPurify to prevent XSS attacks
+     * This replaces the regex-based approach with a more robust solution
+     */
+    static sanitizeString(input) {
+        // Limit input length to prevent DoS
+        if (input.length > 10000) {
+            input = input.substring(0, 10000);
+        }
+        // Initialize DOMPurify if needed
+        this.initializePurify();
+        // Use DOMPurify with strict configuration
+        // ALLOWED_TAGS: [] strips all HTML tags
+        // ALLOWED_ATTR: [] strips all attributes
+        // FORBID_TAGS/FORBID_ATTR provide additional protection
+        let sanitized = this.purify.sanitize(input, {
+            ALLOWED_TAGS: [], // Strip all HTML tags
+            ALLOWED_ATTR: [], // Strip all attributes
+            FORBID_TAGS: ['style', 'script', 'iframe', 'object', 'embed', 'link'],
+            FORBID_ATTR: ['onerror', 'onload', 'onclick', 'onmouseover', 'style', 'href', 'src']
+        });
+        // Additional protection against command injection patterns
+        // These patterns might not be caught by DOMPurify
+        const commandInjectionPatterns = [
+            /`[^`]{0,1000}`/g, // Backtick expressions
+            /\$\([^)]{0,1000}\)/g, // Command substitution
+            /\$\{[^}]{0,1000}\}/g, // Variable expansion
+            /\\x[0-9a-fA-F]{2}/g, // Hex escapes
+            /\\u[0-9a-fA-F]{4}/g, // Unicode escapes
+            /\\[0-7]{1,3}/g // Octal escapes
+        ];
+        for (const pattern of commandInjectionPatterns) {
+            sanitized = sanitized.replace(pattern, '');
+        }
+        // Remove null bytes and normalize whitespace
+        sanitized = sanitized
+            .replace(/\x00/g, '') // Remove null bytes
+            .replace(/[\r\n]+/g, ' ') // Replace newlines with spaces
+            .trim();
+        return sanitized;
+    }
+    /**
+     * Reset static DOMPurify cache (useful for long-running processes)
+     */
+    static resetCache() {
+        this.purifyWindow = null;
+        this.purify = null;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"yamlValidator.js","sourceRoot":"","sources":["../../../src/security/yamlValidator.ts"],"names":[],"mappings":"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","sourcesContent":["import yaml from 'js-yaml';\nimport { z } from 'zod';\nimport { logger } from '../utils/logger.js';\nimport DOMPurify from 'dompurify';\nimport { JSDOM } from 'jsdom';\n\nconst PersonaMetadataSchema = z.object({\n  name: z.string().min(1).max(100),\n  description: z.string().min(1).max(1000),\n  unique_id: z.string().optional(),\n  author: z.string().max(50).optional(),\n  triggers: z.array(z.string().max(50)).max(20).optional(),\n  version: z.string().regex(/^\\d+\\.\\d+\\.\\d+$/).optional(),\n  category: z.enum(['creative', 'professional', 'educational', 'gaming', 'personal']).optional(),\n  age_rating: z.enum(['all', '13+', '18+']).optional(),\n  content_flags: z.array(z.string()).optional(),\n  ai_generated: z.boolean().optional(),\n  generation_method: z.string().max(50).optional(),\n  price: z.string().max(20).optional(),\n  license: z.string().max(100).optional(),\n  created_date: z.string().optional()\n});\n\n// Type declarations for better type safety\ntype DOMPurifyInstance = ReturnType<typeof DOMPurify>;\n\nexport class YamlValidator {\n  // Static cache for DOMPurify to improve performance\n  private static purifyWindow: any = null;\n  private static purify: DOMPurifyInstance | null = null;\n\n  static parsePersonaMetadataSafely(yamlContent: string): any {\n    if (!yamlContent || typeof yamlContent !== 'string') {\n      throw new Error('YAML content must be a non-empty string');\n    }\n    \n    // Size check\n    if (yamlContent.length > 50000) { // 50KB\n      throw new Error('YAML content too large');\n    }\n    \n    // Check for dangerous tags\n    if (yamlContent.includes('!!js/') || yamlContent.includes('!!python/')) {\n      throw new Error('Dangerous YAML tags detected');\n    }\n    \n    // Check for excessive anchors/aliases (YAML bomb protection)\n    const anchorCount = (yamlContent.match(/&\\w+/g) || []).length;\n    const aliasCount = (yamlContent.match(/\\*\\w+/g) || []).length;\n    \n    if (anchorCount > 10 || aliasCount > 20) {\n      throw new Error('Potential YAML bomb detected');\n    }\n    \n    try {\n      // Use safe load with restricted schema\n      const rawData = yaml.load(yamlContent, {\n        schema: yaml.CORE_SCHEMA, // No functions, only basic types\n        onWarning: (warning) => {\n          logger.warn('YAML parsing warning:', warning);\n        }\n      });\n      \n      // Validate against schema\n      const validatedData = PersonaMetadataSchema.parse(rawData);\n      \n      // Additional sanitization\n      return this.sanitizeMetadata(validatedData);\n    } catch (error) {\n      if (error instanceof Error && error.name === 'YAMLException') {\n        throw new Error(`Invalid YAML syntax: ${error.message}`);\n      }\n      throw new Error(`Invalid persona metadata: ${error instanceof Error ? error.message : String(error)}`);\n    }\n  }\n\n  private static sanitizeMetadata(data: any): any {\n    const sanitized = { ...data };\n    \n    // Sanitize string fields\n    const stringFields = ['name', 'description', 'author', 'unique_id'];\n    for (const field of stringFields) {\n      if (sanitized[field]) {\n        sanitized[field] = this.sanitizeString(sanitized[field]);\n      }\n    }\n    \n    // Sanitize array fields\n    if (sanitized.triggers) {\n      sanitized.triggers = sanitized.triggers.map((t: string) => this.sanitizeString(t));\n    }\n    \n    return sanitized;\n  }\n\n  /**\n   * Initialize DOMPurify instance if not already initialized\n   */\n  private static initializePurify(): void {\n    if (!this.purifyWindow || !this.purify) {\n      const dom = new JSDOM('');\n      this.purifyWindow = dom.window;\n      this.purify = DOMPurify(this.purifyWindow);\n    }\n  }\n\n  /**\n   * Sanitize string input using DOMPurify to prevent XSS attacks\n   * This replaces the regex-based approach with a more robust solution\n   */\n  private static sanitizeString(input: string): string {\n    // Limit input length to prevent DoS\n    if (input.length > 10000) {\n      input = input.substring(0, 10000);\n    }\n    \n    // Initialize DOMPurify if needed\n    this.initializePurify();\n    \n    // Use DOMPurify with strict configuration\n    // ALLOWED_TAGS: [] strips all HTML tags\n    // ALLOWED_ATTR: [] strips all attributes\n    // FORBID_TAGS/FORBID_ATTR provide additional protection\n    let sanitized = this.purify!.sanitize(input, {\n      ALLOWED_TAGS: [],      // Strip all HTML tags\n      ALLOWED_ATTR: [],      // Strip all attributes\n      FORBID_TAGS: ['style', 'script', 'iframe', 'object', 'embed', 'link'],\n      FORBID_ATTR: ['onerror', 'onload', 'onclick', 'onmouseover', 'style', 'href', 'src']\n    });\n    \n    // Additional protection against command injection patterns\n    // These patterns might not be caught by DOMPurify\n    const commandInjectionPatterns = [\n      /`[^`]{0,1000}`/g,           // Backtick expressions\n      /\\$\\([^)]{0,1000}\\)/g,       // Command substitution\n      /\\$\\{[^}]{0,1000}\\}/g,       // Variable expansion\n      /\\\\x[0-9a-fA-F]{2}/g,        // Hex escapes\n      /\\\\u[0-9a-fA-F]{4}/g,        // Unicode escapes\n      /\\\\[0-7]{1,3}/g              // Octal escapes\n    ];\n    \n    for (const pattern of commandInjectionPatterns) {\n      sanitized = sanitized.replace(pattern, '');\n    }\n    \n    // Remove null bytes and normalize whitespace\n    sanitized = sanitized\n      .replace(/\\x00/g, '')          // Remove null bytes\n      .replace(/[\\r\\n]+/g, ' ')      // Replace newlines with spaces\n      .trim();\n    \n    return sanitized;\n  }\n  \n  /**\n   * Reset static DOMPurify cache (useful for long-running processes)\n   */\n  public static resetCache(): void {\n    this.purifyWindow = null;\n    this.purify = null;\n  }\n}"]}

package/dist/src/server/ServerSetup.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Server setup and initialization
+ */
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { ToolRegistry } from './tools/ToolRegistry.js';
+import { IToolHandler } from './types.js';
+export declare class ServerSetup {
+    private toolRegistry;
+    constructor();
+    /**
+     * Initialize the server with all tools and handlers
+     */
+    setupServer(server: Server, instance: IToolHandler): void;
+    /**
+     * Register all tool categories
+     */
+    private registerTools;
+    /**
+     * Setup the ListToolsRequest handler
+     */
+    private setupListToolsHandler;
+    /**
+     * Setup the CallToolRequest handler
+     */
+    private setupCallToolHandler;
+    /**
+     * Get the tool registry
+     */
+    getToolRegistry(): ToolRegistry;
+}
+//# sourceMappingURL=ServerSetup.d.ts.map

package/dist/src/server/ServerSetup.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ServerSetup.d.ts","sourceRoot":"","sources":["../../../src/server/ServerSetup.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAE,MAAM,EAAE,MAAM,2CAA2C,CAAC;AAEnE,OAAO,EAAE,YAAY,EAAE,MAAM,yBAAyB,CAAC;AAMvD,OAAO,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAE1C,qBAAa,WAAW;IACtB,OAAO,CAAC,YAAY,CAAe;;IAMnC;;OAEG;IACH,WAAW,CAAC,MAAM,EAAE,MAAM,EAAE,QAAQ,EAAE,YAAY,GAAG,IAAI;IASzD;;OAEG;IACH,OAAO,CAAC,aAAa;IAiBrB;;OAEG;IACH,OAAO,CAAC,qBAAqB;IAQ7B;;OAEG;IACH,OAAO,CAAC,oBAAoB;IA4B5B;;OAEG;IACH,eAAe,IAAI,YAAY;CAGhC"}

package/dist/src/server/ServerSetup.js

@@ -0,0 +1,79 @@
+/**
+ * Server setup and initialization
+ */
+import { CallToolRequestSchema, ErrorCode, ListToolsRequestSchema, McpError } from "@modelcontextprotocol/sdk/types.js";
+import { ToolRegistry } from './tools/ToolRegistry.js';
+import { getPersonaTools } from './tools/PersonaTools.js';
+import { getMarketplaceTools } from './tools/MarketplaceTools.js';
+import { getUserTools } from './tools/UserTools.js';
+import { getUpdateTools } from './tools/UpdateTools.js';
+import { getConfigTools } from './tools/ConfigTools.js';
+export class ServerSetup {
+    toolRegistry;
+    constructor() {
+        this.toolRegistry = new ToolRegistry();
+    }
+    /**
+     * Initialize the server with all tools and handlers
+     */
+    setupServer(server, instance) {
+        // Register all tools
+        this.registerTools(instance);
+        // Setup request handlers
+        this.setupListToolsHandler(server);
+        this.setupCallToolHandler(server);
+    }
+    /**
+     * Register all tool categories
+     */
+    registerTools(instance) {
+        // Register persona tools
+        this.toolRegistry.registerMany(getPersonaTools(instance));
+        // Register marketplace tools
+        this.toolRegistry.registerMany(getMarketplaceTools(instance));
+        // Register user tools
+        this.toolRegistry.registerMany(getUserTools(instance));
+        // Register update tools
+        this.toolRegistry.registerMany(getUpdateTools(instance));
+        // Register config tools
+        this.toolRegistry.registerMany(getConfigTools(instance));
+    }
+    /**
+     * Setup the ListToolsRequest handler
+     */
+    setupListToolsHandler(server) {
+        server.setRequestHandler(ListToolsRequestSchema, async () => {
+            return {
+                tools: this.toolRegistry.getAllTools()
+            };
+        });
+    }
+    /**
+     * Setup the CallToolRequest handler
+     */
+    setupCallToolHandler(server) {
+        server.setRequestHandler(CallToolRequestSchema, async (request) => {
+            const { name, arguments: args } = request.params;
+            try {
+                const handler = this.toolRegistry.getHandler(name);
+                if (!handler) {
+                    throw new McpError(ErrorCode.MethodNotFound, `Unknown tool: ${name}`);
+                }
+                return await handler(args);
+            }
+            catch (error) {
+                if (error instanceof McpError) {
+                    throw error;
+                }
+                throw new McpError(ErrorCode.InternalError, `Error executing tool ${name}: ${error}`);
+            }
+        });
+    }
+    /**
+     * Get the tool registry
+     */
+    getToolRegistry() {
+        return this.toolRegistry;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/src/server/index.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Server module exports
+ */
+export * from './ServerSetup.js';
+export * from './tools/index.js';
+export * from './types.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/src/server/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/server/index.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,cAAc,kBAAkB,CAAC;AACjC,cAAc,kBAAkB,CAAC;AACjC,cAAc,YAAY,CAAC"}

package/dist/src/server/index.js

@@ -0,0 +1,7 @@
+/**
+ * Server module exports
+ */
+export * from './ServerSetup.js';
+export * from './tools/index.js';
+export * from './types.js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvc2VydmVyL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOztHQUVHO0FBRUgsY0FBYyxrQkFBa0IsQ0FBQztBQUNqQyxjQUFjLGtCQUFrQixDQUFDO0FBQ2pDLGNBQWMsWUFBWSxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBTZXJ2ZXIgbW9kdWxlIGV4cG9ydHNcbiAqL1xuXG5leHBvcnQgKiBmcm9tICcuL1NlcnZlclNldHVwLmpzJztcbmV4cG9ydCAqIGZyb20gJy4vdG9vbHMvaW5kZXguanMnO1xuZXhwb3J0ICogZnJvbSAnLi90eXBlcy5qcyc7Il19