push-guardian 1.0.0

package/src/core/errorCMD.js

@@ -0,0 +1,9 @@
+const { getChalk } = require('../utils/chalk-wrapper');
+const chalk = getChalk();
+
+module.exports = (error) => {
+    const stackLines = error.stack.split('\n');
+    const location = stackLines[1] ? stackLines[1].trim() : 'Emplacement inconnu';
+    console.log(chalk.red('💥 Error during validation:'), error.message, location);
+    process.exit(1);
+};

package/src/core/interactiveMenu/interactiveMenu.js

@@ -0,0 +1,73 @@
+const { getChalk } = require('../../utils/chalk-wrapper');
+const chalk = getChalk();
+
+module.exports = (message, choices, preselected = []) => {
+    return new Promise((resolve) => {
+        let currentIndex = 0;
+        let choiseMap = preselected;
+
+        const renderMenu = () => {
+            console.clear();
+            console.log(chalk.blue(message));
+            choices.forEach((choise, index) => {
+                if (index == currentIndex) console.log(chalk.yellow(`> ${choise}`));
+                else if (index != currentIndex && choiseMap.includes(index)) console.log(chalk.green(`* ${choise}`));
+                else console.log(`  ${choise}`);
+            });
+            console.log('\n▲: Up\t▼: Down\t◀: Unselect\t►: Select (Enter to validate, Ctrl+C to quit)');
+        };
+
+        const handleInput = (key) => {
+            if (key == '\u0003') {
+                // QUIT with Ctrl+C
+                process.exit();
+                return;
+            }
+
+            if (key == '\u001B[A') {
+                // UP Arrow
+                currentIndex = (currentIndex - 1 + choices.length) % choices.length;
+                renderMenu();
+            } else if (key == '\u001B[B') {
+                // DOWN Arrow
+                currentIndex = (currentIndex + 1) % choices.length;
+                renderMenu();
+            } else if (key == '\r') {
+                // ENTER
+                process.stdin.setRawMode(false);
+                process.stdin.pause();
+                executeChoise(choiseMap);
+            } else if (key == '\u001B[D') {
+                // Left Arrow
+                const index = choiseMap.indexOf(currentIndex);
+                if (index !== -1) {
+                    choiseMap.splice(index, 1);
+                }
+                renderMenu();
+            } else if (key == '\u001B[C') {
+                // Rigth Arrow
+                choiseMap.push(currentIndex);
+                renderMenu();
+            }
+        };
+
+        const executeChoise = (choiseMap) => {
+            if (!choiseMap.length) {
+                resolve([choices[currentIndex]]);
+            } else {
+                const selectedChoices = choiseMap.map((index) => choices[index]);
+                resolve(selectedChoices);
+            }
+            process.stdin.removeListener('data', handleInput);
+            process.stdin.setRawMode(false);
+            process.stdin.pause();
+        };
+
+        process.stdin.setRawMode(true);
+        process.stdin.resume();
+        process.stdin.setEncoding('utf8');
+        process.stdin.on('data', handleInput);
+
+        renderMenu();
+    });
+};

package/src/core/mirroring/branchSynchronizer.js

@@ -0,0 +1,59 @@
+class BranchSynchronizer {
+    constructor(clients) {
+        this.clients = clients;
+    }
+
+    async syncBranches(srcPlatform, targetPlatform, sourceRepo, targetRepo, sourceOwner, targetOwner) {
+        try {
+            const branches = await this.getBranches(srcPlatform, sourceRepo, sourceOwner);
+
+            for (const branch of branches) {
+                try {
+                    await this.createBranch(targetPlatform, targetRepo, branch, targetOwner);
+                } catch (error) {
+                    console.warn(`⚠️ Impossible de créer la branche ${branch.name}: ${error.message}`);
+                }
+            }
+        } catch (error) {
+            throw new Error(`La synchronisation des branches a échoué: ${error.message}`);
+        }
+    }
+    async getBranches(platform, repoName, owner) {
+        const client = this.clients[platform];
+
+        if (!client) throw new Error(`Plateforme non prise en charge: ${platform}`);
+        if (platform === 'github') {
+            const response = await client.repos.listBranches({ owner, repo: repoName });
+            return response.data;
+        }
+        if (platform === 'gitlab') return await client.Branches.all(repoName);
+        if (platform === 'bitbucket')
+            return await client.repositories.listBranches({ workspace: owner || 'workspace', repo_slug: repoName });
+        throw new Error(`Liste des branches non implémentée pour ${platform}`);
+    }
+
+    async createBranch(platform, repoName, branchData, owner) {
+        const client = this.clients[platform];
+
+        if (!client) throw new Error(`Plateforme non prise en charge: ${platform}`);
+        if (platform === 'github')
+            return await client.git.createRef({
+                owner,
+                repo: repoName,
+                ref: `refs/heads/${branchData.name}`,
+                sha: branchData.commit.sha
+            });
+        if (platform === 'gitlab')
+            return await client.Branches.create(repoName, branchData.name, { ref: branchData.commit.sha });
+        if (platform === 'bitbucket')
+            return await client.repositories.createBranch({
+                workspace: owner || 'workspace',
+                repo_slug: repoName,
+                name: branchData.name,
+                target: { hash: branchData.commit.sha }
+            });
+        throw new Error(`La création de branche n'est pas implémentée pour ${platform}`);
+    }
+}
+
+module.exports = { BranchSynchronizer };

package/src/core/mirroring/generate.js

@@ -0,0 +1,114 @@
+const fs = require('fs');
+const path = require('path');
+const { getChalk } = require('../../utils/chalk-wrapper');
+const chalk = getChalk();
+
+function generateWorkflow() {
+    try {
+        const workflowsDir = path.join(process.cwd(), '.github', 'workflows');
+        if (!fs.existsSync(workflowsDir)) {
+            fs.mkdirSync(workflowsDir, { recursive: true });
+            console.log(chalk.green('✅ Dossier .github/workflows créé'));
+        }
+        const workflowContent = `name: Mirror Repository
+
+on:
+  workflow_dispatch:
+  schedule:
+    - cron: '0 2 * * *'  # Every day at 2 AM UTC
+  push:
+    branches: [ main, master ]
+
+jobs:
+  mirror:
+    runs-on: ubuntu-latest
+
+    steps:
+    - name: Checkout current repository
+      uses: actions/checkout@v4
+      with:
+        path: .
+
+    steps:
+    - name: Checkout push-guardian
+      uses: actions/checkout@v4
+      with:
+        repository: lagie-marin/push-guardian
+        path: push-guardian
+
+    - name: Setup Node.js
+      uses: actions/setup-node@v4
+      with:
+        node-version: '22.20.0'
+        cache: 'npm'
+        cache-dependency-path: push-guardian/package-lock.json
+
+    - name: Install specific npm version
+      run: |
+        echo "Current npm version:"
+        npm --version
+        echo ""
+        echo "Installing npm 11.6.0..."
+        # Désinstaller la version actuelle et installer la version spécifique
+        npm install -g npm@11.6.0 --force
+        echo ""
+        echo "New npm version:"
+        npm --version
+
+    - name: Install dependencies
+      run: |
+        cd push-guardian
+        npm ci
+
+    - name: Link push-guardian globally
+      run: |
+        cd push-guardian
+        npm link
+
+    - name: Execute mirror command
+      run: |
+        CURRENT_REPO="\${{ github.event.repository.name }}"
+        CURRENT_OWNER="\${{ github.event.repository.owner.login }}"
+        
+        mirror_cmd="npx push-guardian mirror"
+        mirror_cmd="$mirror_cmd --source \${{ vars.SOURCE_PLATFORM }}"
+        mirror_cmd="$mirror_cmd --target \${{ vars.TARGET_PLATFORM }}"
+        mirror_cmd="$mirror_cmd --source-repo $CURRENT_REPO"
+        mirror_cmd="$mirror_cmd --repo \${{ vars.TARGET_REPO }}"
+        mirror_cmd="$mirror_cmd --source-owner $CURRENT_OWNER"
+        mirror_cmd="$mirror_cmd --target-owner \${{ vars.TARGET_OWNER }}"
+
+        if [ "\${{ vars.SYNC_BRANCHES }}" = "true" ]; then
+          mirror_cmd="$mirror_cmd --sync-branches"
+        fi
+
+        if [ "\${{ vars.PUBLIC_REPO }}" = "true" ]; then
+          mirror_cmd="$mirror_cmd --public-repo"
+        fi
+
+        echo "Executing: $mirror_cmd"
+        eval $mirror_cmd
+      env:
+        GITHUB_TOKEN: \${{ secrets.GITHUB_TOKEN }}
+        GIT_TOKEN: \${{ secrets.GITHUB_TOKEN }}
+        GITLAB_TOKEN: \${{ secrets.GITLAB_TOKEN }}
+        BIT_BUCKET: \${{ secrets.BIT_BUCKET }}
+        BB_WORKSPACE: \${{ vars.BB_WORKSPACE }}
+        AZURE_DEVOPS_URL: \${{ secrets.AZURE_DEVOPS_URL }}
+        AZURE_DEVOPS_TOKEN: \${{ secrets.AZURE_DEVOPS_TOKEN }}
+`;
+
+        const workflowPath = path.join(workflowsDir, 'mirror.yml');
+        fs.writeFileSync(workflowPath, workflowContent, 'utf8');
+
+        console.log(chalk.green('✅ Workflow GitHub Actions généré : .github/workflows/mirror.yml'));
+        console.log(chalk.blue('ℹ️  Pensez à configurer les variables et secrets dans GitHub Actions'));
+    } catch (error) {
+        console.error(chalk.red(`❌ Erreur lors de la génération du workflow : ${error.message}`));
+        throw error;
+    }
+}
+
+module.exports = {
+    generateWorkflow
+};

package/src/core/mirroring/repoManager.js

@@ -0,0 +1,112 @@
+class RepoManager {
+    constructor(clients) {
+        this.clients = clients;
+    }
+
+    async createOrUpdateRepo(
+        srcPlatform,
+        targetPlatform,
+        sourceRepo,
+        targetRepo,
+        sourceOwner,
+        targetOwner,
+        public_repo = false
+    ) {
+        try {
+            const srcRepo = await this.getRepo(srcPlatform, sourceRepo, sourceOwner);
+            const normalizedSrcRepo = srcRepo && srcRepo.data ? srcRepo.data : srcRepo;
+            const repoData = {
+                name: targetRepo,
+                description: normalizedSrcRepo.description || '',
+                private: normalizedSrcRepo.private || false
+            };
+            await this.createRepo(targetPlatform, repoData, targetOwner, public_repo);
+        } catch (error) {
+            throw new Error(`Échec de la mise en miroir du dépôt: ${error.message}`);
+        }
+    }
+
+    async getRepo(platform, repoName, owner) {
+        const client = this.clients[platform];
+        if (!client) throw new Error(`Plateforme non prise en charge: ${platform}`);
+        if (platform === 'github') return await client.repos.get({ owner, repo: repoName });
+        if (platform === 'gitlab') return await client.Projects.show(repoName);
+        if (platform === 'bitbucket')
+            return await client.repositories.get({ workspace: owner || 'workspace', repo_slug: repoName });
+        throw new Error(`La récupération du dépôt n'est pas implémentée pour ${platform}`);
+    }
+
+    async createRepo(platform, repoData, owner, public_repo = false) {
+        const client = this.clients[platform];
+        if (!client) throw new Error(`Plateforme non prise en charge: ${platform}`);
+        if (platform === 'github') {
+            try {
+                const existingRepo = await client.repos.get({ owner, repo: repoData.name }).catch(() => null);
+                if (existingRepo) {
+                    console.log(
+                        `📁 Le dépôt ${repoData.name} existe déjà chez ${owner}, utilisation du dépôt existant.`
+                    );
+                    return existingRepo.data;
+                }
+                return await client.repos.createForAuthenticatedUser({ ...repoData, private: !public_repo });
+            } catch {
+                try {
+                    return await client.repos.createInOrg({ org: owner, ...repoData, private: !public_repo });
+                } catch (orgError) {
+                    throw new Error(`Impossible de créer le dépôt: ${orgError.message}`);
+                }
+            }
+        }
+        if (platform === 'gitlab') {
+            const projectPath = `${owner}/${repoData.name}`;
+
+            try {
+                const existingByPath = await client.Projects.show(projectPath);
+                if (existingByPath) {
+                    console.log(
+                        `📁 Le dépôt ${repoData.name} existe déjà chez ${owner}, utilisation du dépôt existant.`
+                    );
+                    return existingByPath;
+                }
+            } catch {
+                // Le projet n'existe pas (ou n'est pas accessible), on tente la création juste après.
+            }
+
+            const existing = await client.Projects.search(repoData.name).catch(() => []);
+            const existingRepo = existing.find((p) => p.name === repoData.name && p.namespace.name === owner);
+            if (existingRepo) {
+                console.log(`📁 Le dépôt ${repoData.name} existe déjà chez ${owner}, utilisation du dépôt existant.`);
+                return existingRepo;
+            }
+
+            try {
+                return await client.Projects.create({
+                    ...repoData,
+                    visibility: public_repo ? 'public' : 'private'
+                });
+            } catch (error) {
+                if (error && (error.message || '').toLowerCase().includes('forbidden')) {
+                    throw new Error(
+                        "GitLab a refusé l'opération (Forbidden). Vérifiez que GITLAB_TOKEN a le scope 'api' et les droits de création dans le namespace cible."
+                    );
+                }
+                throw error;
+            }
+        }
+        if (platform === 'bitbucket') {
+            const existing = await client.repositories.list({ workspace: owner || 'workspace' });
+            const existingRepo = existing.data.values.find((r) => r.name === repoData.name);
+            if (existingRepo) {
+                console.log(`📁 Le dépôt ${repoData.name} existe déjà chez ${owner}, utilisation du dépôt existant.`);
+                return existingRepo;
+            }
+            return await client.repositories.create({
+                workspace: owner || 'workspace',
+                repository: { ...repoData, is_private: !public_repo }
+            });
+        }
+        throw new Error(`La création de dépôt n'est pas implémentée pour ${platform}`);
+    }
+}
+
+module.exports = { RepoManager };

package/src/core/mirroring/syncManager.js

@@ -0,0 +1,176 @@
+const { Octokit } = require('@octokit/rest');
+const { WebApi } = require('azure-devops-node-api');
+const { Bitbucket } = require('bitbucket');
+const { Gitlab } = require('gitlab');
+const simpleGit = require('simple-git');
+const path = require('path');
+const fs = require('fs');
+const { RepoManager } = require('./repoManager');
+const { BranchSynchronizer } = require('./branchSynchronizer');
+const { getEnv } = require('../module/env-loader');
+
+class SyncManager {
+    constructor(config) {
+        this.config = config;
+        this.clients = this.initClients();
+        this.repoManager = new RepoManager(this.clients);
+        this.branchSynchronizer = new BranchSynchronizer(this.clients);
+    }
+
+    initClients() {
+        const clients = {};
+
+        if (this.config.github && this.config.github.enabled) {
+            try {
+                const token = getEnv('GITHUB_TOKEN');
+                clients.github = new Octokit({ auth: token });
+            } catch (error) {
+                console.warn(`⚠️  Impossible d'initialiser le client GitHub: ${error.message}`);
+            }
+        }
+
+        if (this.config.gitlab && this.config.gitlab.enabled) {
+            try {
+                const token = getEnv('GITLAB_TOKEN');
+                clients.gitlab = new Gitlab({ token: token });
+            } catch (error) {
+                console.warn(`⚠️  Impossible d'initialiser le client GitLab: ${error.message}`);
+            }
+        }
+
+        if (this.config.bitbucket && this.config.bitbucket.enabled) {
+            try {
+                const username = getEnv('BITBUCKET_USERNAME');
+                const password = getEnv('BITBUCKET_PASSWORD');
+                clients.bitbucket = new Bitbucket({
+                    auth: { username: username, password: password }
+                });
+            } catch (error) {
+                console.warn(`⚠️  Impossible d'initialiser le client BitBucket: ${error.message}`);
+            }
+        }
+
+        if (this.config.azure && this.config.azure.enabled) {
+            try {
+                const url = getEnv('AZURE_DEVOPS_URL');
+                const token = getEnv('AZURE_DEVOPS_TOKEN');
+                clients.azure = new WebApi(url, token);
+            } catch (error) {
+                console.warn(`⚠️  Impossible d'initialiser le client Azure DevOps: ${error.message}`);
+            }
+        }
+
+        return clients;
+    }
+
+    async mirror(
+        sourcePlatform,
+        targetPlatform,
+        sourceRepo,
+        targetRepo,
+        sourceOwner,
+        targetOwner,
+        syncBranches = false,
+        public_repo = false
+    ) {
+        try {
+            await this.repoManager.createOrUpdateRepo(
+                sourcePlatform,
+                targetPlatform,
+                sourceRepo,
+                targetRepo,
+                sourceOwner,
+                targetOwner,
+                public_repo
+            );
+
+            await this.pushCodeToTarget(
+                sourcePlatform,
+                targetPlatform,
+                sourceRepo,
+                targetRepo,
+                sourceOwner,
+                targetOwner
+            );
+
+            if (syncBranches) {
+                await this.branchSynchronizer.syncBranches(
+                    sourcePlatform,
+                    targetPlatform,
+                    sourceRepo,
+                    targetRepo,
+                    sourceOwner,
+                    targetOwner
+                );
+            }
+        } catch (error) {
+            console.error(`❌ Échec de la mise en miroir: ${error.message}`);
+            throw error;
+        }
+    }
+
+    async pushCodeToTarget(sourcePlatform, targetPlatform, sourceRepo, targetRepo, sourceOwner, targetOwner) {
+        if (sourcePlatform !== 'github' || targetPlatform !== 'github') {
+            console.log("⚠️ Le push du code n'est actuellement supporté que pour GitHub vers GitHub");
+            return;
+        }
+
+        const sourceToken = getEnv('GITHUB_TOKEN');
+        const targetToken = sourceToken;
+
+        if (!sourceToken || !targetToken) {
+            console.log('⚠️ Tokens manquants pour pousser le code');
+            return;
+        }
+
+        const tempDir = path.join(process.cwd(), 'temp-mirror-' + Date.now());
+
+        try {
+            fs.mkdirSync(tempDir, { recursive: true });
+
+            const git = simpleGit(tempDir);
+
+            const sourceUrl = `https://${sourceToken}@github.com/${sourceOwner}/${sourceRepo}.git`;
+            console.log('📥 Clonage du dépôt source...');
+            await git.clone(sourceUrl, '.');
+
+            const targetUrl = `https://${targetToken}@github.com/${targetOwner}/${targetRepo}.git`;
+            console.log('📤 Configuration du remote cible...');
+            await git.removeRemote('origin');
+            await git.addRemote('origin', targetUrl);
+
+            console.log('🚀 Push du code vers le dépôt cible...');
+            await git.push('origin', 'main', ['--force']);
+
+            const branches = await git.branch();
+            for (const branch of branches.all) {
+                if (branch !== 'main' && branch !== 'master') {
+                    try {
+                        await git.push('origin', branch, ['--force']);
+                    } catch (error) {
+                        console.warn(`⚠️ Impossible de pousser la branche ${branch}: ${error.message}`);
+                    }
+                }
+            }
+
+            try {
+                await git.pushTags('origin');
+            } catch (error) {
+                console.warn(`⚠️ Impossible de pousser les tags: ${error.message}`);
+            }
+
+            console.log('✅ Code poussé avec succès vers le dépôt cible');
+        } catch (error) {
+            console.error(`❌ Échec du push du code: ${error.message}`);
+            throw error;
+        } finally {
+            try {
+                fs.rmSync(tempDir, { recursive: true, force: true });
+            } catch (cleanupError) {
+                console.warn(`⚠️ Impossible de nettoyer le dossier temporaire: ${cleanupError.message}`);
+            }
+        }
+    }
+}
+
+module.exports = { SyncManager };

package/src/core/module/env-loader.js

@@ -0,0 +1,109 @@
+const fs = require('fs');
+const path = require('path');
+
+/**
+ * Charge les variables d'environnement depuis un fichier .env
+ * @param {string} envPath - Chemin vers le fichier .env (par défaut: '.env')
+ */
+function loadEnv(envPath = '.env') {
+    try {
+        const absolutePath = path.resolve(process.cwd(), envPath);
+
+        if (!fs.existsSync(absolutePath)) {
+            console.warn('⚠️  Fichier .env non trouvé, utilisation des variables système');
+            return;
+        }
+
+        const content = fs.readFileSync(absolutePath, 'utf8');
+        let lines = content.split('\n');
+
+        lines.forEach((line, index) => {
+            line = line.trim();
+            if (!line || line.startsWith('#')) return;
+
+            const match = line.match(/^\s*([\w.-]+)\s*=\s*(.*)?\s*$/);
+            if (!match) {
+                console.warn(`⚠️  Ligne ${index + 1} ignorée (format invalide): ${line}`);
+                return;
+            }
+
+            const key = match[1];
+            let value = match[2] || '';
+
+            if (value.startsWith('"') && value.endsWith('"')) {
+                value = value.slice(1, -1).replace(/\\n/g, '\n');
+            } else if (value.startsWith("'") && value.endsWith("'")) {
+                value = value.slice(1, -1);
+            }
+
+            if (process.env[key] === undefined) {
+                process.env[key] = value;
+            }
+        });
+
+        console.log("✅ Variables d'environnement chargées depuis .env");
+    } catch (error) {
+        console.error('❌ Erreur lors du chargement du fichier .env:', error.message);
+    }
+}
+
+/**
+ * Récupère une variable d'environnement avec validation
+ * @param {string} key - Clé de la variable
+ * @param {*} defaultValue - Valeur par défaut si non trouvée
+ * @returns {string}
+ */
+function getEnv(key, defaultValue = null, werror = false) {
+    const value = process.env[key];
+    if (value === undefined || value === '') {
+        if (defaultValue === null) {
+            if (werror) {
+                throw new Error(`Variable d'environnement manquante: ${key}`);
+            } else {
+                return '';
+            }
+        }
+        return defaultValue;
+    }
+    return value;
+}
+
+/**
+ * Sauvegarde une variable d'environnement dans le fichier .env
+ * @param {string} key - Clé de la variable
+ * @param {string} value - Valeur de la variable
+ * @param {string} envPath - Chemin vers le fichier .env (par défaut: '.env')
+ */
+function saveEnv(key, value, envPath = '.env') {
+    try {
+        const absolutePath = path.resolve(process.cwd(), envPath);
+        let content = '';
+
+        if (fs.existsSync(absolutePath)) {
+            content = fs.readFileSync(absolutePath, 'utf8');
+        }
+
+        const lines = content.split('\n');
+        let updated = false;
+
+        for (let i = 0; i < lines.length; i++) {
+            const line = lines[i].trim();
+            if (line.startsWith(`${key}=`) || line.startsWith(`${key} =`)) {
+                lines[i] = `${key}=${value}`;
+                updated = true;
+                break;
+            }
+        }
+
+        if (!updated) {
+            lines.push(`${key}=${value}`);
+        }
+
+        fs.writeFileSync(absolutePath, lines.join('\n'), 'utf8');
+        console.log(`✅ Variable ${key} sauvegardée dans .env`);
+    } catch (error) {
+        console.error('❌ Erreur lors de la sauvegarde de la variable:', error.message);
+    }
+}
+
+module.exports = { loadEnv, getEnv, saveEnv };