[Feature Request] Local Engine Backup & Restore: Offline backup for downloaded conversion runtimes

[MahmoudhassanGX]

Problem Statement

The application downloads essential conversion runtimes and engines (e.g., LibreOffice, OCR language data, FFmpeg binaries) which can take up considerable disk space and download time.

When an existing user reinstalls Windows or performs a clean OS reset, they have to re-download the entire suite of engines from scratch, even if they already downloaded them previously.

---

Proposed Improvement (Personal Maintenance & Reinstall Utility)

Add a local Backup & Restore utility inside the Engine / Dependencies manager:

1. "Backup Downloaded Engines":
   • Compresses the locally installed engines folder into a single archive file on a chosen local path/storage drive.
2. "Restore Engines from Backup":
   • Allows a user after installing a fresh copy of the app to select their local archive.
   • The app extracts the engines directly into the app data directory and runs a quick integrity/version check.
   • Resumes full offline functionality immediately without re-downloading gigabytes of engine packages.

---

Benefit:

• Saves recurring bandwidth and time for existing users during routine PC maintenance or OS reinstalls.
• Keeps the official app installation flow clean while offering a hassle-free maintenance tool for power users.

[KnifeLemon]

Thanks! This is tracked in #447 (export engines on one PC, import them on another), please follow it there. Until then:

• Use my copy… in Settings → Engines lets Filee use an engine you keep yourself, e.g. a LibreOffice or FFmpeg folder on another drive that survives a reinstall.
• Starting Filee with FILEE_DATA_DIR set keeps the settings and the downloaded engines in that folder ([Feature]: Make it truly portable #631 has a small launcher for it).

[MahmoudhassanGX]

Thanks for the pointer to #447.

While workarounds like FILEE_DATA_DIR or "Use my copy…" are helpful for advanced users, expecting average users to manage folder structures, batch launchers, or environment variables manually is prone to errors, broken paths, and version mismatches.

Since Filee already treats runtimes as distinct modular components, here is a complete architectural proposal for implementing an automated Engine Backup & Restore Package (.zip) that keeps the process secure, verified, and user-friendly.

1. Package Structure & Embedded Manifest
   Exporting should produce a standard .zip containing the engine binaries along with a root manifest.json. The manifest stores engine metadata, version tags, and SHA-256 hashes to guarantee data integrity:

JSON { "filee_version": "2.0.0", "created_at": "2026-10-28T09:00:00Z", "engines": [ { "id": "ffmpeg", "version": "7.0.1", "archive_path": "engines/ffmpeg", "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" }, { "id": "libreoffice", "version": "24.2.3", "archive_path": "engines/libreoffice", "sha256": "4b227777d4dd1fc61c6f884f48641d02b4d121d3fd328cb08b5531fcacdabf8a" } ] }

2. Export Pipeline (EngineExportService)
   Rather than blindly copying folders, the export flow gives the user granular control:

Engine Selection UI: A simple checkbox list allowing the user to pick which engines to package (e.g., backing up FFmpeg and OCR data while omitting a large LibreOffice installation).

Hash & Manifest Generation: Computes the SHA-256 checksum and extracts the version string for each selected runtime.

Packaging: Compresses the selected engines into the archive and writes manifest.json at the root.

`public async Task ExportEnginesAsync(List selectedEngineIds, string targetZipPath, IProgress progress)
{
using var archiveStream = File.Create(targetZipPath);
using var archive = new ZipArchive(archiveStream, ZipArchiveMode.Create);

var manifest = new EngineBackupManifest
{
    FileeVersion = AppVersion.Current,
    CreatedAt = DateTime.UtcNow
};

foreach (var engineId in selectedEngineIds)
{
    var engineDir = _engineLocator.GetEngineDirectory(engineId);
    var entryFolder = $"engines/{engineId}";
    
    // 1. Pack engine files into the archive
    await archive.AddDirectoryAsync(engineDir, entryFolder);
    
    // 2. Generate SHA-256 hash and detect engine version
    var sha256 = await CryptoUtils.ComputeFolderHashAsync(engineDir);
    var version = await _engineVersionDetector.GetVersionAsync(engineId);

    manifest.Engines.Add(new EngineMeta(engineId, version, entryFolder, sha256));
}

// 3. Save manifest inside the root of archive
var manifestEntry = archive.CreateEntry("manifest.json");
using var writer = new StreamWriter(manifestEntry.Open());
await writer.WriteAsync(JsonSerializer.Serialize(manifest, JsonOptions.Default));

}`

3. Import & Conflict Resolution Pipeline (EngineImportService)
   When restoring engines from an archive on a clean setup or another machine:

Pre-Extraction Inspection: The application reads only manifest.json from the ZIP header in memory without unpacking gigabytes of data first.

Version Comparison & Conflict Handling:

New Runtime: Extracted directly into the local data directory.

Identical Version: Marked as already installed / skipped.

Local is Newer: Displays an explicit prompt: “Local FFmpeg is v7.0.1, backup is v6.1. Keep newer local copy or overwrite with backup?”.

Backup is Newer: Updates the local runtime to the backup version.

Selective Restore: The user can review the engines list found in the backup and uncheck any runtime they do not want to restore.

Integrity Verification: After extraction, verifies file checksums against the manifest SHA-256 to ensure the package was not corrupted during storage or transfer

`public async Task<List> InspectBackupAsync(string zipPath)
{
using var archive = ZipFile.OpenRead(zipPath);
var manifestEntry = archive.GetEntry("manifest.json");
if (manifestEntry == null)
throw new InvalidDataException("Invalid backup package: manifest.json not found.");

using var stream = manifestEntry.Open();
var manifest = await JsonSerializer.DeserializeAsync<EngineBackupManifest>(stream);

var previews = new List<EngineImportPreview>();
foreach (var engine in manifest.Engines)
{
    var localVersion = await _engineVersionDetector.GetInstalledVersionAsync(engine.Id);
    var status = ConflictResolver.DetermineStatus(localVersion, engine.Version);

    previews.Add(new EngineImportPreview
    {
        EngineId = engine.Id,
        BackupVersion = engine.Version,
        LocalVersion = localVersion,
        Status = status, // New, Identical, NewerLocal, OlderLocal
        IsSelected = status != ConflictStatus.Identical
    });
}

return previews;

}`

Why an Integrated Solution Matters
Safe for Regular Users: Eliminates the need to fiddle with launch scripts, environment variables, or registry keys that break after clean OS installs or drive letter changes.

Prevents Binary Corruption: The manifest and checksum verification ensure broken or partially copied binaries never cause conversion failures mid-task.

Bandwidth & Storage Efficient: Users can keep a single, version-tagged archive on external storage and restore their entire suite offline in seconds.

Hope this provides a solid, complete reference for moving #447 forward!

[MahmoudhassanGX]

Verification Note: This proposal and the proposed architecture are verified against the latest Filee-main codebase pulled on October 28, 2026 at 07:10 UTC. All proposed pipelines match the modular engine locator and dependency structure currently present in the repository.

[KnifeLemon]

Thanks for the detailed design! To keep it in one place, I'm closing this as a duplicate of #447, which follows exporting the downloaded engines and importing them on another PC. The manifest with versions and SHA-256 hashes is a good starting point there.