BackupProfile.uc.js - div. Fragen dazu

// ==UserScript==
// @name           ProfileBackupRestore@Fu_combo_zipRoot_withlog.uc.js
// @description    Navbar: Backup(Ordner1 + ZIP2) + Restore(Backup1->Profil) + Log in Ordner1
// @version        2026.07-combo-zip-root-log
// ==/UserScript==

(function () {
  "use strict";

  if (location.href !== "chrome://browser/content/browser.xhtml") return;
  if (typeof CustomizableUI === "undefined") return;
  if (!window.gBrowser) return;

  const PROFILES = [
    
	{
      label: "Reserve 3",
      profilePath: "C:\\Users\\Old Man\\AppData\\Roaming\\Mozilla\\Firefox\\Profiles\\Reserve 3",
      profileName: "Reserve 3",
      backup1Path: "G:\\BackupRestore Firefox\\Reserve 3",
      archiveRootPath: "E:\\BackupRestore Firefox\\Reserve 3",
      iconPath: "file:///C:/FoxIcons2/Finale.png"
    },
	{
      label: "Portable.Firefox.Updater.3_Stable ",
      profilePath: "G:\\Portable.Firefox.Updater.3\\Firefox Stable x64\\profile",
      profileName: "profile",
      backup1Path: "G:\\BackupRestore Firefox\\Portable.Firefox.Updater.3_Stable",
	  archiveRootPath: "E:\\BackupRestore Firefox\\Portable.Firefox.Updater.3_Stable",
      iconPath: "file:///C:/FoxIcons2/Finale.png"
    },
	{
      label: "Portable.Firefox.Updater.3_Nightly ",
      profilePath: "G:\\Portable.Firefox.Updater.3\\Firefox Nightly x64\\profile",
      profileName: "profile",
      backup1Path: "G:\\BackupRestore Firefox\\Portable.Firefox.Updater.3_Nightly",
	  archiveRootPath: "E:\\BackupRestore Firefox\\Portable.Firefox.Updater.3_Nightly",
      iconPath: "file:///C:/FoxIcons2/Nightly.png"
    }
  ];

  const BTN_ID = "profilebackup_restore_combo_ziproot_withlog";
  const POPUP_ID = BTN_ID + "_popup";

  const btnIconPath = "file:///C:/FoxIcons2/backup.png";

  // =========================
  // Logging helpers
  // =========================
  function pad2(n) {
    return String(n).padStart(2, "0");
  }

  function timeHHMM(d) {
    return "[" + pad2(d.getHours()) + ":" + pad2(d.getMinutes()) + "]";
  }

  function formatHeaderDateGermanLong(d) {
    const weekdays = ["Sonntag", "Montag", "Dienstag", "Mittwoch", "Donnerstag", "Freitag", "Samstag"];
    const months = ["Januar", "Februar", "März", "April", "Mai", "Juni", "Juli", "August", "September", "Oktober", "November", "Dezember"];
    const wd = weekdays[d.getDay()];
    const mn = months[d.getMonth()];
    return "am " + wd + ", " +
      pad2(d.getDate()) + ". " + mn + " " + d.getFullYear() + ", " +
      pad2(d.getHours()) + ":" + pad2(d.getMinutes()) + ":" + pad2(d.getSeconds()) + " Uhr";
  }

  function getLogFile(profile) {
    const f = new FileUtils.File(profile.backup1Path);
    f.append("ProfileBackupRestore.log");
    return f;
  }

  function ensureParentForFile(file) {
    const parent = file.parent;
    if (!parent || !parent.exists()) {
      // backup1Path ist bei dir der Parent; falls nicht existiert, versuche zu erstellen
      // (best effort)
      try { parent.create(Ci.nsIFile.DIRECTORY_TYPE, 0o755); } catch (_) {}
    }
  }

  function appendTextToFile(file, text) {
    try {
      ensureParentForFile(file);
      if (!file.exists()) {
        file.create(Ci.nsIFile.NORMAL_FILE_TYPE, 0o644);
      }

      const fos = Cc["@mozilla.org/network/file-output-stream;1"].createInstance(Ci.nsIFileOutputStream);
      fos.init(file, 0x02 | 0x08 | 0x10, 0o644, 0); // write | create | append

      const conv = Cc["@mozilla.org/intl/converter-output-stream;1"].createInstance(Ci.nsIConverterOutputStream);
      conv.init(fos, "UTF-8", 0, 0);
      conv.writeString(text);
      conv.close();

      try { fos.close(); } catch (_) {}
    } catch (e) {
      console.error("Log Fehler:", e);
    }
  }

  function logRestore(profile, destProfilePath) {
    const dStart = new Date();

    const header = "Profil in alten Zustand versetzt " + formatHeaderDateGermanLong(dStart) + "\n\n";
    const lines =
      timeHHMM(dStart) + " Restore gestartet (Firefox-Erkennung deaktiviert).\n" +
      timeHHMM(dStart) + " Lösche vorhandenen Profilordner: " + destProfilePath + "\n" +
      timeHHMM(dStart) + " Kopiere Sicherung nach: " + destProfilePath + "\n" +
      timeHHMM(new Date()) + " Restore erfolgreich abgeschlossen.\n";

    appendTextToFile(getLogFile(profile), header + "\n" + lines + "\n");
  }

  function logBackup(profile, backupTargetPath, zipPath) {
    const dStart = new Date();

    const header = "Profil gesichert " + formatHeaderDateGermanLong(dStart) + "\n\n";
    const lines =
      timeHHMM(dStart) + " Backup gestartet (Firefox-Erkennung deaktiviert).\n" +
      timeHHMM(dStart) + " Lösche vorhandenen Profilordner: " + backupTargetPath + "\n" +
      timeHHMM(dStart) + " Kopiere Profil nach: " + backupTargetPath + "\n" +
      timeHHMM(new Date()) + " Erzeuge Archiv ZIP: " + zipPath + "\n" +
      timeHHMM(new Date()) + " Backup erfolgreich abgeschlossen.\n";

    appendTextToFile(getLogFile(profile), header + "\n" + lines + "\n");
  }

  // =========================
  // Alert
  // =========================
  function showAlert(text) {
    try {
      let w = null;
      try { w = Services.wm.getMostRecentWindow("navigator:browser"); } catch (_) {}
      Services.prompt.alert(w || null, "Profilsicherung", text);
    } catch (e) {
      console.error("Alert Fehler:", e);
    }
  }

  // =========================
  // Date/Zähler ZIP2
  // =========================
  function pad2Str(n) {
    const x = parseInt(n, 10);
    if (isNaN(x)) return "00";
    return pad2(x);
  }

  function getDateStrYYYYMMDD(d) {
    return d.getFullYear() + "-" + pad2(d.getMonth() + 1) + "-" + pad2(d.getDate());
  }

  function escapeRegExp(s) {
    return String(s).replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
  }

  function getNextDailyZipIndex(archiveRootFile, profileName, dateStr) {
    let max = 0;
    const re = new RegExp("^" + escapeRegExp(profileName) + "_" + escapeRegExp(dateStr) + "_(\\d{2})\\.zip$");

    let entries = archiveRootFile.directoryEntries;
    while (entries.hasMoreElements()) {
      const entry = entries.getNext().QueryInterface(Ci.nsIFile);
      if (!entry.isFile()) continue;

      const m = re.exec(entry.leafName);
      if (m) {
        const n = parseInt(m[1], 10);
        if (!isNaN(n) && n > max) max = n;
      }
    }
    return max + 1; // => startet bei 01
  }

  // =========================
  // Skip-Dateien (WAL/SHM/Locks)
  // =========================
  function shouldSkipEntryByName(name) {
    if (name === "parent.lock") return true;
    if (name === "lock") return true;
    if (name === "recovery.jsonlz4") return true;
    if (name.endsWith(".sqlite-wal")) return true;
    if (name.endsWith(".sqlite-shm")) return true;
    return false;
  }

  // =========================
  // Copy helpers
  // =========================
  function copyDirectoryContents(srcDir, destDir) {
    let entries = srcDir.directoryEntries;
    while (entries.hasMoreElements()) {
      const entry = entries.getNext().QueryInterface(Ci.nsIFile);

      if (shouldSkipEntryByName(entry.leafName)) continue;

      const destEntry = destDir.clone();
      destEntry.append(entry.leafName);

      try {
        if (entry.isDirectory()) {
          if (!destEntry.exists()) destEntry.create(Ci.nsIFile.DIRECTORY_TYPE, 0o755);
          copyDirectoryContents(entry, destEntry);
        } else {
          if (destEntry.exists()) destEntry.remove(false);
          entry.copyTo(destDir, entry.leafName);
        }
      } catch (e) {
        console.warn("⚠️ Kopie fehlgeschlagen:", entry.path, e);
      }
    }
  }

  function clearDirectoryContents(dir) {
    let entries = dir.directoryEntries;
    while (entries.hasMoreElements()) {
      const entry = entries.getNext().QueryInterface(Ci.nsIFile);
      try { entry.remove(true); } catch (e) {
        console.warn("⚠️ Clear fehlgeschlagen:", entry.path, e);
      }
    }
  }

  // =========================
  // ZIP erstellen: Inhalt + Root = profile.profileName
  // =========================
  function zipDirectoryWithRoot(sourceDir, zipFile, rootNameInZip) {
    const baseDirPath = sourceDir.path;

    if (zipFile.exists()) zipFile.remove(true);

    const zipWriter = Cc["@mozilla.org/zipwriter;1"].createInstance(Ci.nsIZipWriter);

    const PR_WRONLY = 0x02;
    const PR_CREATE_FILE = 0x08;
    const PR_TRUNCATE = 0x20;

    zipWriter.open(zipFile, PR_WRONLY | PR_CREATE_FILE | PR_TRUNCATE);

    function walk(dir) {
      let entries = dir.directoryEntries;
      while (entries.hasMoreElements()) {
        const entry = entries.getNext().QueryInterface(Ci.nsIFile);

        if (entry.path === zipFile.path) continue;
        if (shouldSkipEntryByName(entry.leafName)) continue;

        if (entry.isDirectory()) {
          walk(entry);
          continue;
        }

        // relPath relativ zum sourceDir, ohne führenden Slash
        let relPath = entry.path.replace(baseDirPath, "");
        if (!relPath) return;
        if (relPath[0] === "\\" || relPath[0] === "/") relPath = relPath.substring(1);

        const saveInZipAs = (rootNameInZip + "/" + relPath).replace(/\\/g, "/");

        try {
          zipWriter.addEntryFile(
            saveInZipAs,
            Ci.nsIZipWriter.COMPRESSION_FASTEST,
            entry,
            false
          );
        } catch (e) {
          console.warn("⚠️ ZIP Eintrag fehlgeschlagen:", saveInZipAs, e);
        }
      }
    }

    walk(sourceDir);
    zipWriter.close();
  }

  // =========================
  // Backup (Ordner1 + ZIP2)
  // =========================
  function runBackup(profile) {
    let backupTarget = null;
    let zipFile = null;

    try {
      const now = new Date();

      const profileDir = new FileUtils.File(profile.profilePath);
      if (!profileDir.exists()) throw new Error("Profilordner existiert nicht: " + profile.profilePath);

      const backupRoot = new FileUtils.File(profile.backup1Path);
      if (!backupRoot.exists()) backupRoot.create(Ci.nsIFile.DIRECTORY_TYPE, 0o755);

      const archiveRoot = new FileUtils.File(profile.archiveRootPath);
      if (!archiveRoot.exists()) archiveRoot.create(Ci.nsIFile.DIRECTORY_TYPE, 0o755);

      // BACKUP 1 Ziel: backupRoot/<profileName>
      backupTarget = backupRoot.clone();
      backupTarget.append(profile.profileName);

      if (backupTarget.exists()) backupTarget.remove(true);
      backupTarget.create(Ci.nsIFile.DIRECTORY_TYPE, 0o755);

      copyDirectoryContents(profileDir, backupTarget);

      // BACKUP 2 ZIP: archiveRoot/<profileName>_YYYY-MM-DD_XX.zip (XX ab 01)
      const dateStr = getDateStrYYYYMMDD(now);
      const nextIdx = getNextDailyZipIndex(archiveRoot, profile.profileName, dateStr);
      const idxStr = pad2Str(nextIdx);

      const zipName = profile.profileName + "_" + dateStr + "_" + idxStr + ".zip";
      zipFile = archiveRoot.clone();
      zipFile.append(zipName);

      // ZIP-Inhalt soll als Root den profile.profileName Ordner haben.
      // Wir zippen den Inhalt von backupTarget, Root in der ZIP = profile.profileName.
      zipDirectoryWithRoot(backupTarget, zipFile, profile.profileName);

      if (!zipFile.exists()) throw new Error("ZIP wurde nicht erstellt: " + zipFile.path);

      // Log in Ordner 1
      try { logBackup(profile, backupTarget.path, zipFile.path); } catch (_) {}

      setTimeout(() => {
        showAlert(
          "✅ Backup abgeschlossen!\n\n" +
          "👤 Profil: " + profile.label + "\n\n" +
          "📁 Backup Ordner 1: " + backupTarget.path + "\n" +
          "📦 Archiv ZIP: " + zipFile.path
        );
      }, 50);

    } catch (e) {
      console.error("Backup Fehler:", e);

      // Best effort Cleanup ZIP, falls vorhanden
      try { if (zipFile && zipFile.exists()) zipFile.remove(false); } catch (_) {}

      setTimeout(() => showAlert("❌ Backup Fehler: " + e.message), 0);
    }
  }

  // =========================
  // Restore (Backup1 -> Profil überschreibt; Wrapper fix!)
  // =========================
  function runRestore(profile) {
    let profileDir = null;
    let backupRootDir = null;
    let backupProfileDir = null;

    try {
      profileDir = new FileUtils.File(profile.profilePath);
      if (!profileDir.exists()) throw new Error("Zielprofil existiert nicht: " + profile.profilePath);

      backupRootDir = new FileUtils.File(profile.backup1Path);
      if (!backupRootDir.exists()) throw new Error("Backup1 Ordner existiert nicht: " + profile.backup1Path);

      // Wrapper fix:
      // Backup1 enthält i.d.R. <profileName>/... -> daraus restaurieren:
      backupProfileDir = backupRootDir.clone();
      backupProfileDir.append(profile.profileName);

      // Fallback falls Backup1 doch direkt Root ist
      if (!backupProfileDir.exists()) backupProfileDir = backupRootDir;

      const ok = Services.prompt.confirm(
        null,
        "Profilsicherung (Restore)",
        "Restore jetzt starten für: " + profile.label + "\n\n" +
        "Quelle: " + backupProfileDir.path + "\n" +
        "Ziel: " + profileDir.path + "\n\n" +
        "WICHTIG: Firefox bitte vorher vollständig beenden.\nFortfahren?"
      );

      if (!ok) return;

      clearDirectoryContents(profileDir);
      copyDirectoryContents(backupProfileDir, profileDir);

      try { logRestore(profile, profileDir.path); } catch (_) {}

      setTimeout(() => {
        showAlert(
          "✅ Restore abgeschlossen!\n\n" +
          "👤 Profil: " + profile.label + "\n\n" +
          "📁 Quelle: " + backupProfileDir.path + "\n" +
          "📁 Ziel: " + profileDir.path + "\n\n" +
          "Hinweis: Starte Firefox danach neu."
        );
      }, 50);

    } catch (e) {
      console.error("Restore Fehler:", e);
      setTimeout(() => showAlert("❌ Restore Fehler: " + e.message), 0);
    }
  }

  // =========================
  // Menü
  // =========================
  function createMenu(doc) {
    const menupopup = doc.createXULElement("menupopup");
    menupopup.setAttribute("id", POPUP_ID);

    PROFILES.forEach((profile) => {
      const backupItem = doc.createXULElement("menuitem");
      backupItem.setAttribute("label", "Backup: " + profile.label);
      backupItem.setAttribute("class", "menuitem-iconic");
      if (profile.iconPath) backupItem.setAttribute("image", profile.iconPath);

      backupItem.addEventListener("command", () => {
        const ok = Services.prompt.confirm(
          null,
          "Profilsicherung",
          "Backup jetzt starten für: " + profile.label + " ?"
        );
        if (ok) runBackup(profile);
      });

      menupopup.appendChild(backupItem);
    });

    const sep = doc.createXULElement("menuseparator");
    menupopup.appendChild(sep);

    PROFILES.forEach((profile) => {
      const restoreItem = doc.createXULElement("menuitem");
      restoreItem.setAttribute("label", "Restore: " + profile.label);
      restoreItem.setAttribute("class", "menuitem-iconic");
      if (profile.iconPath) restoreItem.setAttribute("image", profile.iconPath);

      restoreItem.addEventListener("command", () => runRestore(profile));
      menupopup.appendChild(restoreItem);
    });

    return menupopup;
  }

  // =========================
  // Button Patch
  // =========================
  function patchButton(btn) {
    if (!btn) return false;

    const oldPopup = btn.querySelector("#" + POPUP_ID);
    if (oldPopup) oldPopup.remove();

    btn.setAttribute("type", "menu");
    btn.setAttribute("aria-haspopup", "true");
    btn.setAttribute("tooltiptext", "Backup & Restore");
    btn.setAttribute("image", btnIconPath);

    btn.appendChild(createMenu(btn.ownerDocument));

    btn.addEventListener("click", (ev) => {
      if (ev.button !== 0) return;
      try {
        const p = btn.querySelector("#" + POPUP_ID);
        if (p) p.openPopup(btn, "after_start", 0, 0, false, false);
      } catch (_) {}
    }, false);

    return true;
  }

  // =========================
  // Widget erstellen
  // =========================
  try {
    if (CustomizableUI.getWidget && CustomizableUI.getWidget(BTN_ID)) {
      try { CustomizableUI.destroyWidget(BTN_ID); } catch (_) {}
    }
  } catch (_) {}

  try {
    const el = document.getElementById(BTN_ID);
    if (el) el.remove();
  } catch (_) {}

  CustomizableUI.createWidget({
    id: BTN_ID,
    defaultArea: CustomizableUI.AREA_NAVBAR,
    label: "Profilsicherung",
    tooltiptext: "Backup & Restore (ZIP Root = profileName) + Log",
    onCreated: (button) => setTimeout(() => patchButton(button), 0)
  });

  // =========================
  // CSS (dein Layout)
  // =========================
  const css = `
#${BTN_ID} .toolbarbutton-icon {
    width: 31px !important;
    height: 31px !important;
    padding: 5px  !important;
}

#${BTN_ID}_popup {
    max-width: 250px !important;
    min-width: 250px !important;
}

#${BTN_ID}_popup menuitem.menuitem-iconic img.menu-icon {
    margin-left: -28px !important;
}

#${BTN_ID}_popup menuitem.menuitem-iconic label.menu-text {
    margin-left: 6px !important;
}
  `;

  const sss = Cc["@mozilla.org/content/style-sheet-service;1"].getService(Ci.nsIStyleSheetService);
  const ios = Cc["@mozilla.org/network/io-service;1"].getService(Ci.nsIIOService);
  const uri = ios.newURI("data:text/css;charset=utf-8," + encodeURIComponent(css), null, null);
  sss.loadAndRegisterSheet(uri, sss.USER_SHEET);

})();

// ==UserScript==
// @name           BackupProfile.uc.js
// @description    Schaltfläche zum Sichern des Firefoxprofils
// @charset        UTF-8
// @author         Mira Bellenbaum
// @version        v2026.09.03
// @note           Sicherungsdatei enthaelt auch Profilname
// ==UserScript==

/* ----------------------------------------------------------------------------------- */
/*     Zu beachten ist, dass die Grafiken sich im richtigen Ordner befinden müssen     */
/*            %appdata%\Mozilla\Firefox\Profiles\"Profilname"\chrome\icons             */
/* ----------------------------------------------------------------------------------- */

/* ----------------------------------------------------------------------------------- */
/*  IMPORTANT!         This script was edited and modified using AI.                   */
/* ----------------------------------------------------------------------------------- */

'use strict';

(function() {
  if (location.href !== 'chrome://browser/content/browser.xhtml')
    return;

  const
  // ■■ START UserConfiguration ■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■
           id = 'backupProfile-button',          // ID des Buttons
        label = 'Profilsicherung',               // Bezeichnung des Buttons
  tooltiptext = 'Sichern der aktuellen Konfiguration',
         icon = 'backup.svg',                    // Name des SVG-Icons
       colour = '#faea00',                     // Farbe für das SVG-Icon
     iconPath = '/chrome/icons/',                // Pfad zum Icon-Ordner
     basePath = 'E:\\Firefox-Sicherung\\',       // Standard-Speicherpfad (leer lassen für Dialog)
   // Ausschlussliste (Dateien/Ordner, die nicht gesichert werden sollen)
   excludes = 'bookmarkbackups *cache* crashes fftmp *healthreport* minidumps safebrowsing *webapps* saved-telemetry-pings *thumbnails* *session* *Telemetry* *hotfix* *.sqlite-shm *.sqlite-wal *.bak parent.lock blocklist.xml content-prefs.sqlite directoryLinks.json mimeTypes.rdf compatibility.ini parent.lock formhistory.sqlite',
  // ■■ END UserConfiguration ■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■

  curProfDir = PathUtils.toFileURI(PathUtils.join(PathUtils.profileDir));

  // SVG-Unterstützung aktivieren (falls nicht bereits aktiv)
  if (Services.prefs.getBoolPref('svg.context-properties.content.enabled') == false) {
    Services.prefs.setBoolPref('svg.context-properties.content.enabled', true);
  }

  // ---- BUTTON ERSTELLEN ----
  try {
    CustomizableUI.createWidget({
      id: id,
      defaultArea: CustomizableUI.AREA_NAVBAR,
      label: label,
      tooltiptext: tooltiptext,
      onCreated: (button) => {
        button.style.MozContextProperties = 'fill, stroke, fill-opacity';
        button.style.listStyleImage = 'url("' + curProfDir + iconPath + icon + '")';
        button.style.minWidth = 'fit-content';
        button.style.color = colour;
      }
    });
  } catch(e) {}

  // ---- FUNKTIONEN ----
  // Benachrichtigung anzeigen
  function showAlert(aTitle, aString) {
    const AlertNotification = Components.Constructor(
      '@mozilla.org/alert-notification;1',
      'nsIAlertNotification',
      'initWithObject'
    );
    Cc['@mozilla.org/alerts-service;1'].getService(Ci.nsIAlertsService).showAlert(
      new AlertNotification({ title: aTitle, text: aString })
    );
  }

  // Backup durchführen
  function performBackup() {
    let path = basePath;

    // Falls kein Pfad angegeben, Dialog öffnen
    if (!path) {
      const nsIFilePicker = Ci.nsIFilePicker;
      const FP = Cc['@mozilla.org/filepicker;1'].createInstance(nsIFilePicker);
      FP.init(window, 'Sicherungspfad wählen', nsIFilePicker.modeGetFolder);

      if (FP.show() !== nsIFilePicker.returnOK) {
        return;
      }
      path = FP.file.path;
    }

    // Ausschlussliste in Regex umwandeln
    const excludesRegex = new RegExp(
      excludes.replace(/\./g, '\\.').replace(/\*/g, '.*').replace(/\s+/g, '|'),
      'i'
    );

    // ZipWriter vorbereiten
    const zw = Cc['@mozilla.org/zipwriter;1'].createInstance(Ci.nsIZipWriter);
    const pr = {PR_RDONLY: 0x01, PR_WRONLY: 0x02, PR_RDWR: 0x04, PR_CREATE_FILE: 0x08, PR_APPEND: 0x10, PR_TRUNCATE: 0x20, PR_SYNC: 0x40, PR_EXCL: 0x80};
    const fu = ChromeUtils.importESModule('resource://gre/modules/FileUtils.sys.mjs').FileUtils;
    const dir = new FileUtils.File(PathUtils.join(PathUtils.profileDir, []));

    // Datum/Zeit für Archivnamen
    const d = new Date();
    const dateStr = d.getDate().toString().padStart(2, '0') + '.' +
                   (d.getMonth() + 1).toString().padStart(2, '0') + '.' +
                   d.getFullYear() + ' - ' +
                   d.getHours().toString().padStart(2, '0') + '\u2236' +
                   d.getMinutes().toString().padStart(2, '0');

    const archiveName = 'Profil Andreas ' + AppConstants.MOZ_APP_VERSION_DISPLAY + ' - ' + dateStr + '.zip';
    const xpi = fu.File(path + '\\' + archiveName);

    // Zip-Datei erstellen
    zw.open(xpi, pr.PR_RDWR | pr.PR_CREATE_FILE | pr.PR_TRUNCATE);
    const dirArr = [dir];

    for (let i = 0; i < dirArr.length; i++) {
      const dirEntries = dirArr[i].directoryEntries;
      while (dirEntries.hasMoreElements()) {
        const entry = dirEntries.getNext().QueryInterface(Ci.nsIFile);

        if (entry.path === xpi.path) continue;

        if (entry.isDirectory()) {
          dirArr.push(entry);
        }

        const relPath = entry.path.replace(dirArr[0].path, '');
        if (relPath.match(excludesRegex)) continue;

        const saveInZipAs = relPath.substr(1).replace(/\\/g, '/');
        try {
          zw.addEntryFile(saveInZipAs, Ci.nsIZipWriter.COMPRESSION_FASTEST, entry, false);
        } catch (e) {}
      }
    }
    zw.close();

    // Erfolgmeldung
    showAlert('Profilsicherung', 'Die aktuelle Konfiguration wurde als:\n' + archiveName + '\ngesichert in:\n' + path);
  }

  // ---- KLICK-HANDLER ----
  (function setupClickHandler() {
    const button = document.getElementById(id);
    if (button) {
      button.addEventListener('click', event => {
        if (event.button !== 0) return;
        performBackup();
      });
    } else {
      setTimeout(setupClickHandler, 100);
    }
  })();

})();