bolt.new/app/utils/autoRecovery.ts

/**
 * Automatic Recovery System
 * Copyright (c) 2024 Ervin Remus Radosavlevici
 * All rights reserved.
 * Contact: radosavlevici.ervin@gmail.com
 * 
 * This file implements automatic recovery mechanisms for stolen code.
 */

import { createScopedLogger } from './logger';

const logger = createScopedLogger('AutoRecovery');

// Configuration
const recoveryConfig = {
  owner: 'Ervin Remus Radosavlevici',
  email: 'radosavlevici.ervin@gmail.com',
  githubUsername: 'radosavlevici',
  autoScanEnabled: true,
  autoReportEnabled: true,
  scanFrequency: 7, // days
};

/**
 * Scan for potential code theft
 */
export async function scanForCodeTheft(): Promise<void> {
  try {
    logger.info('Scanning for potential code theft');
    
    // In a real implementation, this would:
    // 1. Use GitHub API to search for similar code
    // 2. Use code similarity algorithms to detect copies
    // 3. Check for unauthorized forks of your repositories
    
    // For demonstration, we'll just log the scan
    logger.info('Code theft scan completed');
    
    // Store the last scan time
    if (typeof localStorage !== 'undefined') {
      localStorage.setItem('lastCodeTheftScan', new Date().toISOString());
    }
  } catch (error) {
    logger.error('Failed to scan for code theft:', error);
  }
}

/**
 * Check if a scan is due based on the configured frequency
 */
export function isScanDue(): boolean {
  try {
    if (typeof localStorage === 'undefined') return true;
    
    const lastScan = localStorage.getItem('lastCodeTheftScan');
    if (!lastScan) return true;
    
    const lastScanDate = new Date(lastScan);
    const now = new Date();
    
    // Calculate days since last scan
    const daysSinceLastScan = (now.getTime() - lastScanDate.getTime()) / (1000 * 60 * 60 * 24);
    
    return daysSinceLastScan >= recoveryConfig.scanFrequency;
  } catch {
    return true;
  }
}

/**
 * Generate a DMCA takedown notice for a specific repository
 */
export function generateDMCAForRepo(repoUrl: string): string {
  const today = new Date().toISOString().split('T')[0];
  
  return `
DMCA Takedown Notice

Date: ${today}

To GitHub, Inc.:

I have read and understand GitHub's Guide to Filing a DMCA Notice.

I, ${recoveryConfig.owner}, am the copyright owner of content that is being infringed in the following repository:

${repoUrl}

The original content, for which I own the exclusive copyright, can be found in my repositories at:
https://github.com/${recoveryConfig.githubUsername}

The unauthorized copying and distribution of my code constitutes copyright infringement under the Copyright Act, 17 U.S.C. §§ 106 and 501.

I have a good faith belief that use of the copyrighted materials described above on the infringing web pages is not authorized by the copyright owner, or its agent, or the law.

I swear, under penalty of perjury, that the information in this notification is accurate and that I am the copyright owner, or am authorized to act on behalf of the owner, of an exclusive right that is allegedly infringed.

I request that GitHub expeditiously remove or disable access to the infringing repository.

Sincerely,

${recoveryConfig.owner}
Email: ${recoveryConfig.email}
`;
}

/**
 * Automatically report a repository for copyright violation
 */
export async function reportRepository(repoUrl: string): Promise<void> {
  try {
    logger.info(`Preparing to report repository: ${repoUrl}`);
    
    // Generate DMCA notice
    const dmcaNotice = generateDMCAForRepo(repoUrl);
    
    // In a real implementation, this would:
    // 1. Send the DMCA notice to a reporting service
    // 2. Create a record of the violation
    // 3. Notify the owner via email
    
    logger.info('Repository reported for copyright violation');
    
    // Store the report in local storage for reference
    if (typeof localStorage !== 'undefined') {
      const reports = JSON.parse(localStorage.getItem('copyrightReports') || '[]');
      reports.push({
        repoUrl,
        date: new Date().toISOString(),
        dmcaNotice
      });
      localStorage.setItem('copyrightReports', JSON.stringify(reports));
    }
  } catch (error) {
    logger.error('Failed to report repository:', error);
  }
}

/**
 * Get a list of previously reported repositories
 */
export function getReportedRepositories(): Array<{repoUrl: string, date: string}> {
  try {
    if (typeof localStorage === 'undefined') return [];
    
    const reports = JSON.parse(localStorage.getItem('copyrightReports') || '[]');
    return reports;
  } catch {
    return [];
  }
}

/**
 * Initialize the automatic recovery system
 */
export function initializeAutoRecovery(): void {
  try {
    logger.info('Initializing automatic recovery system');
    
    // Run initial scan if enabled and due
    if (recoveryConfig.autoScanEnabled && isScanDue()) {
      scanForCodeTheft();
    }
    
    // Set up periodic scans
    if (typeof window !== 'undefined' && recoveryConfig.autoScanEnabled) {
      // Check daily if a scan is due
      setInterval(() => {
        if (isScanDue()) {
          scanForCodeTheft();
        }
      }, 24 * 60 * 60 * 1000); // Check once per day
    }
    
    logger.info('Automatic recovery system initialized');
  } catch (error) {
    logger.error('Failed to initialize automatic recovery system:', error);
  }
}

// Initialize the recovery system
if (typeof window !== 'undefined') {
  // Wait for the page to load
  window.addEventListener('load', () => {
    setTimeout(initializeAutoRecovery, 5000);
  });
}

// Export for explicit initialization if needed
export default {
  scanForCodeTheft,
  reportRepository,
  getReportedRepositories,
  initialize: initializeAutoRecovery,
  config: recoveryConfig
};