@dollhousemcp/mcp-server 1.3.0

package/dist/test/src/update/RateLimiter.js

@@ -0,0 +1,172 @@
+/**
+ * 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 || !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 = 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 msUntilNextToken = tokensNeeded / this.refillRate;
+            return {
+                allowed: false,
+                retryAfterMs: Math.ceil(msUntilNextToken),
+                remainingTokens: 0,
+                resetTime: new Date(now + msUntilNextToken)
+            };
+        }
+        // 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
+        });
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"RateLimiter.js","sourceRoot":"","sources":["../../../../src/update/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 || !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 = 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 msUntilNextToken = tokensNeeded / this.refillRate;\n      \n      return {\n        allowed: false,\n        retryAfterMs: Math.ceil(msUntilNextToken),\n        remainingTokens: 0,\n        resetTime: new Date(now + msUntilNextToken)\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}"]}

package/dist/test/src/update/SignatureVerifier.d.ts

@@ -0,0 +1,71 @@
+/**
+ * SignatureVerifier - Verifies GitHub release signatures to ensure authenticity
+ *
+ * Security features:
+ * - Verifies GPG signatures on git tags
+ * - Validates release artifacts checksums
+ * - Ensures releases come from trusted sources
+ * - Prevents tampering and supply chain attacks
+ */
+export interface SignatureVerificationResult {
+    verified: boolean;
+    signerKey?: string;
+    signerEmail?: string;
+    signatureDate?: Date;
+    error?: string;
+}
+export interface ChecksumVerificationResult {
+    verified: boolean;
+    expectedChecksum?: string;
+    actualChecksum?: string;
+    error?: string;
+}
+export declare class SignatureVerifier {
+    private trustedKeys;
+    private allowUnsignedInDev;
+    constructor(options?: {
+        trustedKeys?: string[];
+        allowUnsignedInDev?: boolean;
+    });
+    /**
+     * Verify a git tag signature
+     * @param tagName The tag to verify (e.g., 'v1.2.0')
+     * @returns Verification result with signer information
+     */
+    verifyTagSignature(tagName: string): Promise<SignatureVerificationResult>;
+    /**
+     * Verify a file checksum against expected value
+     * @param filePath Path to the file to verify
+     * @param expectedChecksum Expected SHA256 checksum
+     * @returns Verification result
+     */
+    verifyChecksum(filePath: string, expectedChecksum: string): Promise<ChecksumVerificationResult>;
+    /**
+     * Verify release artifacts using a checksums file
+     * @param checksumsFile Path to checksums file (e.g., SHA256SUMS)
+     * @param artifactDir Directory containing artifacts to verify
+     * @returns Map of filename to verification result
+     */
+    verifyReleaseArtifacts(checksumsFile: string, artifactDir: string): Promise<Map<string, ChecksumVerificationResult>>;
+    /**
+     * Add a trusted key for signature verification
+     * @param keyId GPG key ID or fingerprint
+     */
+    addTrustedKey(keyId: string): void;
+    /**
+     * Remove a trusted key
+     * @param keyId GPG key ID or fingerprint
+     */
+    removeTrustedKey(keyId: string): void;
+    /**
+     * Get list of trusted keys
+     */
+    getTrustedKeys(): string[];
+    /**
+     * Import a GPG public key
+     * @param keyData The public key data to import
+     * @returns Success status
+     */
+    importPublicKey(keyData: string): Promise<boolean>;
+}
+//# sourceMappingURL=SignatureVerifier.d.ts.map

package/dist/test/src/update/SignatureVerifier.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SignatureVerifier.d.ts","sourceRoot":"","sources":["../../../../src/update/SignatureVerifier.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AASH,MAAM,WAAW,2BAA2B;IAC1C,QAAQ,EAAE,OAAO,CAAC;IAClB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,aAAa,CAAC,EAAE,IAAI,CAAC;IACrB,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAED,MAAM,WAAW,0BAA0B;IACzC,QAAQ,EAAE,OAAO,CAAC;IAClB,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAED,qBAAa,iBAAiB;IAC5B,OAAO,CAAC,WAAW,CAAc;IACjC,OAAO,CAAC,kBAAkB,CAAU;gBAExB,OAAO,CAAC,EAAE;QACpB,WAAW,CAAC,EAAE,MAAM,EAAE,CAAC;QACvB,kBAAkB,CAAC,EAAE,OAAO,CAAC;KAC9B;IAWD;;;;OAIG;IACG,kBAAkB,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,2BAA2B,CAAC;IAkF/E;;;;;OAKG;IACG,cAAc,CAAC,QAAQ,EAAE,MAAM,EAAE,gBAAgB,EAAE,MAAM,GAAG,OAAO,CAAC,0BAA0B,CAAC;IA2BrG;;;;;OAKG;IACG,sBAAsB,CAC1B,aAAa,EAAE,MAAM,EACrB,WAAW,EAAE,MAAM,GAClB,OAAO,CAAC,GAAG,CAAC,MAAM,EAAE,0BAA0B,CAAC,CAAC;IAiCnD;;;OAGG;IACH,aAAa,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI;IAIlC;;;OAGG;IACH,gBAAgB,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI;IAIrC;;OAEG;IACH,cAAc,IAAI,MAAM,EAAE;IAI1B;;;;OAIG;IACG,eAAe,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;CAoBzD"}

package/dist/test/src/update/SignatureVerifier.js

@@ -0,0 +1,214 @@
+/**
+ * SignatureVerifier - Verifies GitHub release signatures to ensure authenticity
+ *
+ * Security features:
+ * - Verifies GPG signatures on git tags
+ * - Validates release artifacts checksums
+ * - Ensures releases come from trusted sources
+ * - Prevents tampering and supply chain attacks
+ */
+import { safeExec } from '../utils/git.js';
+import * as crypto from 'crypto';
+import * as fs from 'fs/promises';
+import * as path from 'path';
+import { randomBytes } from 'crypto';
+import { logger } from '../utils/logger.js';
+export class SignatureVerifier {
+    trustedKeys;
+    allowUnsignedInDev;
+    constructor(options) {
+        // Default trusted keys - should be GPG key IDs of maintainers
+        this.trustedKeys = new Set(options?.trustedKeys || [
+        // Add trusted GPG key fingerprints here
+        // Example: '1234567890ABCDEF1234567890ABCDEF12345678'
+        ]);
+        // Allow unsigned releases in development mode
+        this.allowUnsignedInDev = options?.allowUnsignedInDev ?? true;
+    }
+    /**
+     * Verify a git tag signature
+     * @param tagName The tag to verify (e.g., 'v1.2.0')
+     * @returns Verification result with signer information
+     */
+    async verifyTagSignature(tagName) {
+        try {
+            // Check if GPG is available
+            try {
+                await safeExec('gpg', ['--version']);
+            }
+            catch {
+                return {
+                    verified: false,
+                    error: 'GPG is not installed or not available in PATH'
+                };
+            }
+            // Verify the tag signature
+            const { stdout, stderr } = await safeExec('git', ['verify-tag', tagName]);
+            // Parse GPG output (comes on stderr)
+            const output = stderr || stdout;
+            // Check for good signature
+            if (!output.includes('Good signature')) {
+                // Check if tag is unsigned
+                if (output.includes('error: no signature found')) {
+                    if (this.allowUnsignedInDev && process.env.NODE_ENV !== 'production') {
+                        return {
+                            verified: true,
+                            error: 'Tag is unsigned (allowed in development mode)'
+                        };
+                    }
+                    return {
+                        verified: false,
+                        error: 'Tag is not signed'
+                    };
+                }
+                return {
+                    verified: false,
+                    error: 'Invalid signature'
+                };
+            }
+            // Extract signer information
+            const keyMatch = output.match(/key (?:ID )?([A-F0-9]+)/i);
+            const emailMatch = output.match(/"([^"]+)"/);
+            const dateMatch = output.match(/made (\w+ \w+ \d+ \d+:\d+:\d+ \d+ \w+)/);
+            const signerKey = keyMatch ? keyMatch[1] : undefined;
+            const signerEmail = emailMatch ? emailMatch[1] : undefined;
+            const signatureDate = dateMatch ? new Date(dateMatch[1]) : undefined;
+            // Check if key is trusted
+            if (this.trustedKeys.size > 0 && signerKey) {
+                // Check if the key ID ends with any of our trusted keys
+                const isTrusted = Array.from(this.trustedKeys).some(trustedKey => signerKey.endsWith(trustedKey.toUpperCase()));
+                if (!isTrusted) {
+                    return {
+                        verified: false,
+                        signerKey,
+                        signerEmail,
+                        signatureDate,
+                        error: `Signature is valid but key ${signerKey} is not in trusted keys list`
+                    };
+                }
+            }
+            return {
+                verified: true,
+                signerKey,
+                signerEmail,
+                signatureDate
+            };
+        }
+        catch (error) {
+            return {
+                verified: false,
+                error: `Failed to verify signature: ${error instanceof Error ? error.message : String(error)}`
+            };
+        }
+    }
+    /**
+     * Verify a file checksum against expected value
+     * @param filePath Path to the file to verify
+     * @param expectedChecksum Expected SHA256 checksum
+     * @returns Verification result
+     */
+    async verifyChecksum(filePath, expectedChecksum) {
+        try {
+            // Read file and calculate checksum
+            const fileBuffer = await fs.readFile(filePath);
+            const hash = crypto.createHash('sha256');
+            hash.update(fileBuffer);
+            const actualChecksum = hash.digest('hex');
+            // Compare checksums
+            const verified = actualChecksum.toLowerCase() === expectedChecksum.toLowerCase();
+            return {
+                verified,
+                expectedChecksum,
+                actualChecksum,
+                error: verified ? undefined : 'Checksum mismatch'
+            };
+        }
+        catch (error) {
+            return {
+                verified: false,
+                expectedChecksum,
+                error: `Failed to verify checksum: ${error instanceof Error ? error.message : String(error)}`
+            };
+        }
+    }
+    /**
+     * Verify release artifacts using a checksums file
+     * @param checksumsFile Path to checksums file (e.g., SHA256SUMS)
+     * @param artifactDir Directory containing artifacts to verify
+     * @returns Map of filename to verification result
+     */
+    async verifyReleaseArtifacts(checksumsFile, artifactDir) {
+        const results = new Map();
+        try {
+            // Read checksums file
+            const checksumsContent = await fs.readFile(checksumsFile, 'utf-8');
+            const lines = checksumsContent.split('\n').filter(line => line.trim());
+            // Parse checksums (format: "checksum  filename" or "checksum *filename")
+            for (const line of lines) {
+                const match = line.match(/^([a-f0-9]+)\s+\*?(.+)$/i);
+                if (!match)
+                    continue;
+                const [, checksum, filename] = match;
+                const filePath = path.join(artifactDir, filename);
+                // Verify each file
+                const result = await this.verifyChecksum(filePath, checksum);
+                results.set(filename, result);
+            }
+            return results;
+        }
+        catch (error) {
+            // If we can't read the checksums file, mark all as unverified
+            results.set('*', {
+                verified: false,
+                error: `Failed to read checksums file: ${error instanceof Error ? error.message : String(error)}`
+            });
+            return results;
+        }
+    }
+    /**
+     * Add a trusted key for signature verification
+     * @param keyId GPG key ID or fingerprint
+     */
+    addTrustedKey(keyId) {
+        this.trustedKeys.add(keyId.toUpperCase());
+    }
+    /**
+     * Remove a trusted key
+     * @param keyId GPG key ID or fingerprint
+     */
+    removeTrustedKey(keyId) {
+        this.trustedKeys.delete(keyId.toUpperCase());
+    }
+    /**
+     * Get list of trusted keys
+     */
+    getTrustedKeys() {
+        return Array.from(this.trustedKeys);
+    }
+    /**
+     * Import a GPG public key
+     * @param keyData The public key data to import
+     * @returns Success status
+     */
+    async importPublicKey(keyData) {
+        try {
+            // Write key data to temporary file with secure random name
+            const tempFile = path.join(process.cwd(), `.gpg-import-${randomBytes(8).toString('hex')}.asc`);
+            await fs.writeFile(tempFile, keyData);
+            try {
+                // Import the key
+                await safeExec('gpg', ['--import', tempFile]);
+                return true;
+            }
+            finally {
+                // Clean up temp file
+                await fs.unlink(tempFile).catch(() => { });
+            }
+        }
+        catch (error) {
+            logger.error('Failed to import GPG key:', error);
+            return false;
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"SignatureVerifier.js","sourceRoot":"","sources":["../../../../src/update/SignatureVerifier.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * SignatureVerifier - Verifies GitHub release signatures to ensure authenticity\n * \n * Security features:\n * - Verifies GPG signatures on git tags\n * - Validates release artifacts checksums\n * - Ensures releases come from trusted sources\n * - Prevents tampering and supply chain attacks\n */\n\nimport { safeExec } from '../utils/git.js';\nimport * as crypto from 'crypto';\nimport * as fs from 'fs/promises';\nimport * as path from 'path';\nimport { randomBytes } from 'crypto';\nimport { logger } from '../utils/logger.js';\n\nexport interface SignatureVerificationResult {\n  verified: boolean;\n  signerKey?: string;\n  signerEmail?: string;\n  signatureDate?: Date;\n  error?: string;\n}\n\nexport interface ChecksumVerificationResult {\n  verified: boolean;\n  expectedChecksum?: string;\n  actualChecksum?: string;\n  error?: string;\n}\n\nexport class SignatureVerifier {\n  private trustedKeys: Set<string>;\n  private allowUnsignedInDev: boolean;\n  \n  constructor(options?: {\n    trustedKeys?: string[];\n    allowUnsignedInDev?: boolean;\n  }) {\n    // Default trusted keys - should be GPG key IDs of maintainers\n    this.trustedKeys = new Set(options?.trustedKeys || [\n      // Add trusted GPG key fingerprints here\n      // Example: '1234567890ABCDEF1234567890ABCDEF12345678'\n    ]);\n    \n    // Allow unsigned releases in development mode\n    this.allowUnsignedInDev = options?.allowUnsignedInDev ?? true;\n  }\n  \n  /**\n   * Verify a git tag signature\n   * @param tagName The tag to verify (e.g., 'v1.2.0')\n   * @returns Verification result with signer information\n   */\n  async verifyTagSignature(tagName: string): Promise<SignatureVerificationResult> {\n    try {\n      // Check if GPG is available\n      try {\n        await safeExec('gpg', ['--version']);\n      } catch {\n        return {\n          verified: false,\n          error: 'GPG is not installed or not available in PATH'\n        };\n      }\n      \n      // Verify the tag signature\n      const { stdout, stderr } = await safeExec('git', ['verify-tag', tagName]);\n      \n      // Parse GPG output (comes on stderr)\n      const output = stderr || stdout;\n      \n      // Check for good signature\n      if (!output.includes('Good signature')) {\n        // Check if tag is unsigned\n        if (output.includes('error: no signature found')) {\n          if (this.allowUnsignedInDev && process.env.NODE_ENV !== 'production') {\n            return {\n              verified: true,\n              error: 'Tag is unsigned (allowed in development mode)'\n            };\n          }\n          return {\n            verified: false,\n            error: 'Tag is not signed'\n          };\n        }\n        \n        return {\n          verified: false,\n          error: 'Invalid signature'\n        };\n      }\n      \n      // Extract signer information\n      const keyMatch = output.match(/key (?:ID )?([A-F0-9]+)/i);\n      const emailMatch = output.match(/\"([^\"]+)\"/);\n      const dateMatch = output.match(/made (\\w+ \\w+ \\d+ \\d+:\\d+:\\d+ \\d+ \\w+)/);\n      \n      const signerKey = keyMatch ? keyMatch[1] : undefined;\n      const signerEmail = emailMatch ? emailMatch[1] : undefined;\n      const signatureDate = dateMatch ? new Date(dateMatch[1]) : undefined;\n      \n      // Check if key is trusted\n      if (this.trustedKeys.size > 0 && signerKey) {\n        // Check if the key ID ends with any of our trusted keys\n        const isTrusted = Array.from(this.trustedKeys).some(trustedKey => \n          signerKey.endsWith(trustedKey.toUpperCase())\n        );\n        \n        if (!isTrusted) {\n          return {\n            verified: false,\n            signerKey,\n            signerEmail,\n            signatureDate,\n            error: `Signature is valid but key ${signerKey} is not in trusted keys list`\n          };\n        }\n      }\n      \n      return {\n        verified: true,\n        signerKey,\n        signerEmail,\n        signatureDate\n      };\n      \n    } catch (error) {\n      return {\n        verified: false,\n        error: `Failed to verify signature: ${error instanceof Error ? error.message : String(error)}`\n      };\n    }\n  }\n  \n  /**\n   * Verify a file checksum against expected value\n   * @param filePath Path to the file to verify\n   * @param expectedChecksum Expected SHA256 checksum\n   * @returns Verification result\n   */\n  async verifyChecksum(filePath: string, expectedChecksum: string): Promise<ChecksumVerificationResult> {\n    try {\n      // Read file and calculate checksum\n      const fileBuffer = await fs.readFile(filePath);\n      const hash = crypto.createHash('sha256');\n      hash.update(fileBuffer);\n      const actualChecksum = hash.digest('hex');\n      \n      // Compare checksums\n      const verified = actualChecksum.toLowerCase() === expectedChecksum.toLowerCase();\n      \n      return {\n        verified,\n        expectedChecksum,\n        actualChecksum,\n        error: verified ? undefined : 'Checksum mismatch'\n      };\n      \n    } catch (error) {\n      return {\n        verified: false,\n        expectedChecksum,\n        error: `Failed to verify checksum: ${error instanceof Error ? error.message : String(error)}`\n      };\n    }\n  }\n  \n  /**\n   * Verify release artifacts using a checksums file\n   * @param checksumsFile Path to checksums file (e.g., SHA256SUMS)\n   * @param artifactDir Directory containing artifacts to verify\n   * @returns Map of filename to verification result\n   */\n  async verifyReleaseArtifacts(\n    checksumsFile: string, \n    artifactDir: string\n  ): Promise<Map<string, ChecksumVerificationResult>> {\n    const results = new Map<string, ChecksumVerificationResult>();\n    \n    try {\n      // Read checksums file\n      const checksumsContent = await fs.readFile(checksumsFile, 'utf-8');\n      const lines = checksumsContent.split('\\n').filter(line => line.trim());\n      \n      // Parse checksums (format: \"checksum  filename\" or \"checksum *filename\")\n      for (const line of lines) {\n        const match = line.match(/^([a-f0-9]+)\\s+\\*?(.+)$/i);\n        if (!match) continue;\n        \n        const [, checksum, filename] = match;\n        const filePath = path.join(artifactDir, filename);\n        \n        // Verify each file\n        const result = await this.verifyChecksum(filePath, checksum);\n        results.set(filename, result);\n      }\n      \n      return results;\n      \n    } catch (error) {\n      // If we can't read the checksums file, mark all as unverified\n      results.set('*', {\n        verified: false,\n        error: `Failed to read checksums file: ${error instanceof Error ? error.message : String(error)}`\n      });\n      return results;\n    }\n  }\n  \n  /**\n   * Add a trusted key for signature verification\n   * @param keyId GPG key ID or fingerprint\n   */\n  addTrustedKey(keyId: string): void {\n    this.trustedKeys.add(keyId.toUpperCase());\n  }\n  \n  /**\n   * Remove a trusted key\n   * @param keyId GPG key ID or fingerprint\n   */\n  removeTrustedKey(keyId: string): void {\n    this.trustedKeys.delete(keyId.toUpperCase());\n  }\n  \n  /**\n   * Get list of trusted keys\n   */\n  getTrustedKeys(): string[] {\n    return Array.from(this.trustedKeys);\n  }\n  \n  /**\n   * Import a GPG public key\n   * @param keyData The public key data to import\n   * @returns Success status\n   */\n  async importPublicKey(keyData: string): Promise<boolean> {\n    try {\n      // Write key data to temporary file with secure random name\n      const tempFile = path.join(process.cwd(), `.gpg-import-${randomBytes(8).toString('hex')}.asc`);\n      await fs.writeFile(tempFile, keyData);\n      \n      try {\n        // Import the key\n        await safeExec('gpg', ['--import', tempFile]);\n        return true;\n      } finally {\n        // Clean up temp file\n        await fs.unlink(tempFile).catch(() => {});\n      }\n      \n    } catch (error) {\n      logger.error('Failed to import GPG key:', error);\n      return false;\n    }\n  }\n}"]}

package/dist/test/src/update/UpdateChecker.d.ts

@@ -0,0 +1,127 @@
+/**
+ * UpdateChecker - Secure GitHub release update checking with comprehensive sanitization
+ *
+ * Security measures implemented:
+ * 1. XSS Protection: DOMPurify with strict no-tags/no-attributes policy
+ * 2. Command Injection Prevention: Multiple regex patterns for various escape sequences
+ * 3. URL Validation: Whitelist approach allowing only http/https schemes
+ * 4. Information Disclosure Prevention: Sanitized logging of sensitive data
+ * 5. Length Limits: Configurable limits to prevent DoS attacks
+ * 6. OWASP Patterns: Protection against PHP, ASP, hex, unicode, and octal escapes
+ *
+ * Performance optimizations:
+ * - Cached DOMPurify instance to avoid recreation overhead
+ * - Single-pass regex processing for injection patterns
+ * - Exponential backoff for network retries
+ */
+import { VersionManager } from './VersionManager.js';
+import { RateLimiter } from './RateLimiter.js';
+import { SignatureVerifier } from './SignatureVerifier.js';
+export interface UpdateCheckResult {
+    currentVersion: string;
+    latestVersion: string;
+    isUpdateAvailable: boolean;
+    releaseDate: string;
+    releaseNotes: string;
+    releaseUrl: string;
+    tagName?: string;
+    signatureVerified?: boolean;
+    signerInfo?: string;
+}
+export declare class UpdateChecker {
+    private versionManager;
+    private rateLimiter;
+    private signatureVerifier;
+    private static purifyWindow;
+    private static purify;
+    private readonly releaseNotesMaxLength;
+    private readonly urlMaxLength;
+    private readonly securityLogger?;
+    private readonly requireSignedReleases;
+    constructor(versionManager: VersionManager, options?: {
+        releaseNotesMaxLength?: number;
+        urlMaxLength?: number;
+        securityLogger?: (event: string, details: any) => void;
+        rateLimiter?: RateLimiter;
+        signatureVerifier?: SignatureVerifier;
+        requireSignedReleases?: boolean;
+    });
+    /**
+     * Execute a network operation with retry logic and exponential backoff
+     * @param operation - The async operation to execute
+     * @param maxRetries - Maximum number of retry attempts (default: 3)
+     * @param baseDelay - Base delay in milliseconds for exponential backoff (default: 1000ms)
+     * @returns Promise resolving to the operation result
+     * @throws The last error if all retries fail
+     */
+    private retryNetworkOperation;
+    /**
+     * Check for updates from GitHub releases with security and error handling
+     * @returns UpdateCheckResult if update info is available, null if no releases found
+     * @throws Error for network or API failures or rate limit exceeded
+     */
+    checkForUpdates(): Promise<UpdateCheckResult | null>;
+    /**
+     * Get current rate limit status
+     * @returns Current rate limit status including remaining requests and reset time
+     */
+    getRateLimitStatus(): {
+        allowed: boolean;
+        remainingRequests: number;
+        resetTime: Date;
+        waitTimeSeconds?: number;
+    };
+    /**
+     * Format update check results for display with comprehensive sanitization
+     * @param result - The update check result to format
+     * @param error - Optional error from update check
+     * @param personaIndicator - Optional persona indicator prefix
+     * @returns Formatted string safe for display
+     */
+    formatUpdateCheckResult(result: UpdateCheckResult | null, error?: Error, personaIndicator?: string): string;
+    /**
+     * Sanitize URLs to prevent dangerous schemes and information disclosure
+     *
+     * Security measures:
+     * - Length validation to prevent DoS
+     * - Whitelist approach: only http/https allowed
+     * - Sanitized logging to prevent sensitive data exposure
+     *
+     * @param url - The URL to sanitize
+     * @returns Empty string if invalid/dangerous, original URL if safe
+     */
+    private sanitizeUrl;
+    /**
+     * Sanitize release notes to prevent XSS, command injection, and DoS
+     *
+     * Security layers:
+     * 1. Length limiting (configurable, default 5000 chars)
+     * 2. HTML/JS sanitization via DOMPurify (no tags/attributes allowed)
+     * 3. Command injection pattern removal (backticks, command substitution)
+     * 4. OWASP pattern removal (PHP, ASP, hex/unicode/octal escapes)
+     *
+     * @param notes - The release notes to sanitize
+     * @returns Sanitized release notes safe for display
+     */
+    private sanitizeReleaseNotes;
+    /**
+     * Format date to human-readable format with consistent timezone handling
+     * @param dateStr - ISO date string to format
+     * @returns Human-readable date string (e.g., "January 5, 2025")
+     */
+    private formatDate;
+    /**
+     * Log security events for monitoring and alerting
+     * Only logs if securityLogger callback was provided in constructor
+     * @param event - The security event type
+     * @param details - Event details (sanitized to prevent info disclosure)
+     */
+    private logSecurityEvent;
+    /**
+     * Reset static DOMPurify cache (useful for long-running processes)
+     * This prevents memory accumulation in services that run for extended periods
+     * @static
+     */
+    static resetCache(): void;
+}
+//# sourceMappingURL=UpdateChecker.d.ts.map

package/dist/test/src/update/UpdateChecker.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"UpdateChecker.d.ts","sourceRoot":"","sources":["../../../../src/update/UpdateChecker.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAGH,OAAO,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAC;AACrD,OAAO,EAAE,WAAW,EAAsB,MAAM,kBAAkB,CAAC;AACnE,OAAO,EAAE,iBAAiB,EAAE,MAAM,wBAAwB,CAAC;AAK3D,MAAM,WAAW,iBAAiB;IAChC,cAAc,EAAE,MAAM,CAAC;IACvB,aAAa,EAAE,MAAM,CAAC;IACtB,iBAAiB,EAAE,OAAO,CAAC;IAC3B,WAAW,EAAE,MAAM,CAAC;IACpB,YAAY,EAAE,MAAM,CAAC;IACrB,UAAU,EAAE,MAAM,CAAC;IACnB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,iBAAiB,CAAC,EAAE,OAAO,CAAC;IAC5B,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AAKD,qBAAa,aAAa;IACxB,OAAO,CAAC,cAAc,CAAiB;IACvC,OAAO,CAAC,WAAW,CAAc;IACjC,OAAO,CAAC,iBAAiB,CAAoB;IAK7C,OAAO,CAAC,MAAM,CAAC,YAAY,CAAa;IACxC,OAAO,CAAC,MAAM,CAAC,MAAM,CAAkC;IAGvD,OAAO,CAAC,QAAQ,CAAC,qBAAqB,CAAS;IAC/C,OAAO,CAAC,QAAQ,CAAC,YAAY,CAAS;IACtC,OAAO,CAAC,QAAQ,CAAC,cAAc,CAAC,CAAwC;IACxE,OAAO,CAAC,QAAQ,CAAC,qBAAqB,CAAU;gBAG9C,cAAc,EAAE,cAAc,EAC9B,OAAO,CAAC,EAAE;QACR,qBAAqB,CAAC,EAAE,MAAM,CAAC;QAC/B,YAAY,CAAC,EAAE,MAAM,CAAC;QACtB,cAAc,CAAC,EAAE,CAAC,KAAK,EAAE,MAAM,EAAE,OAAO,EAAE,GAAG,KAAK,IAAI,CAAC;QACvD,WAAW,CAAC,EAAE,WAAW,CAAC;QAC1B,iBAAiB,CAAC,EAAE,iBAAiB,CAAC;QACtC,qBAAqB,CAAC,EAAE,OAAO,CAAC;KACjC;IA+CH;;;;;;;OAOG;YACW,qBAAqB;IAgCnC;;;;OAIG;IACG,eAAe,IAAI,OAAO,CAAC,iBAAiB,GAAG,IAAI,CAAC;IA4H1D;;;OAGG;IACH,kBAAkB,IAAI;QACpB,OAAO,EAAE,OAAO,CAAC;QACjB,iBAAiB,EAAE,MAAM,CAAC;QAC1B,SAAS,EAAE,IAAI,CAAC;QAChB,eAAe,CAAC,EAAE,MAAM,CAAC;KAC1B;IAUD;;;;;;OAMG;IACH,uBAAuB,CAAC,MAAM,EAAE,iBAAiB,GAAG,IAAI,EAAE,KAAK,CAAC,EAAE,KAAK,EAAE,gBAAgB,GAAE,MAAW,GAAG,MAAM;IAoF/G;;;;;;;;;;OAUG;IACH,OAAO,CAAC,WAAW;IAiCnB;;;;;;;;;;;OAWG;IACH,OAAO,CAAC,oBAAoB;IA+E5B;;;;OAIG;IACH,OAAO,CAAC,UAAU;IAmBlB;;;;;OAKG;IACH,OAAO,CAAC,gBAAgB;IAMxB;;;;OAIG;WACW,UAAU,IAAI,IAAI;CAIjC"}