prepare for multiple apps

2026-04-06 12:23:11 +02:00
parent bd1600e8dc
commit 5afc323f04
904 changed files with 29 additions and 29 deletions
@@ -0,0 +1,185 @@
+/*
+ * Copyright (c) 2024-2026 Fabian Freund.
+ *
+ * This file is part of WebLibre
+ * (see https://weblibre.eu).
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as
+ * published by the Free Software Foundation, either version 3 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+import 'dart:async';
+import 'dart:convert';
+import 'dart:io';
+
+import 'package:path/path.dart' as p;
+import 'package:uuid/uuid_value.dart';
+import 'package:weblibre/core/logger.dart';
+import 'package:weblibre/domain/entities/profile.dart';
+
+const profilesDirName = 'weblibre_profiles';
+const profileDirPrefix = 'profile-';
+
+const _startupProfileFileName = 'current_profile';
+const _metadataFile = 'metadata.json';
+
+final profileTransformer =
+    StreamTransformer<FileSystemEntity, Directory>.fromHandlers(
+      handleData: (entity, sink) {
+        if (entity is Directory &&
+            p.basename(entity.path).startsWith(profileDirPrefix)) {
+          sink.add(entity);
+        }
+      },
+    );
+
+Future<List<Directory>> getAvailableProfileDirectories(Directory profilesDir) {
+  return profilesDir.list().transform(profileTransformer).toList();
+}
+
+Future<void> clearMozillaProfileCache(
+  Directory profileDir,
+  String profileId,
+) async {
+  final cacheDir = Directory(p.join(profileDir.path, 'cache'));
+  final mozillaCacheDir = Directory(p.join(cacheDir.path, profileId));
+
+  if (await mozillaCacheDir.exists()) {
+    await mozillaCacheDir.delete(recursive: true);
+  }
+}
+
+/// Returns the list of Mozilla profile IDs (`.default` directory names)
+/// inside the given profile directory's `files/mozilla/` subdirectory.
+List<String> getMozillaProfileIds(Directory profileDir) {
+  final mozillaDir = Directory(p.join(profileDir.path, 'files', 'mozilla'));
+  if (!mozillaDir.existsSync()) return [];
+
+  return mozillaDir
+      .listSync()
+      .whereType<Directory>()
+      .map((dir) => p.basename(dir.path))
+      .where((name) => name.endsWith('.default'))
+      .toList();
+}
+
+Future<UuidValue?> readStartupProfile(Directory dir) async {
+  final file = File(p.join(dir.path, _startupProfileFileName));
+
+  if (await file.exists()) {
+    final contents = await file.readAsString();
+    try {
+      return UuidValue.withValidation(contents);
+    } catch (e, s) {
+      logger.e('Could not parse profile', error: e, stackTrace: s);
+    }
+  }
+
+  return null;
+}
+
+Future<void> writeStartupProfile(
+  Directory dir,
+  UuidValue profile, {
+  bool flush = false,
+}) async {
+  final file = File(p.join(dir.path, _startupProfileFileName));
+  await file.writeAsString(profile.uuid, flush: flush);
+}
+
+Future<UuidValue?> selectStartupProfile(Directory profilesDir) async {
+  var startupProfile = await readStartupProfile(profilesDir);
+  final availableProfiles = await getAvailableProfileDirectories(profilesDir);
+
+  // Verify the startup profile directory actually exists
+  if (startupProfile != null) {
+    final profileDir = getProfileDir(profilesDir, startupProfile);
+    final exists = availableProfiles.any((dir) => dir.path == profileDir.path);
+    if (!exists) {
+      logger.w('Startup profile directory missing, selecting fallback');
+      startupProfile = null;
+    }
+  }
+
+  if (startupProfile == null) {
+    final sortedDirs = await sortByAccessTime(availableProfiles);
+
+    for (final dir in sortedDirs) {
+      try {
+        startupProfile = extractDirectoryUuid(dir);
+        await writeStartupProfile(profilesDir, startupProfile);
+
+        break;
+      } catch (e, s) {
+        logger.w('Could not parse profile folder', error: e, stackTrace: s);
+      }
+    }
+  }
+
+  return startupProfile;
+}
+
+UuidValue extractDirectoryUuid(Directory dir) => UuidValue.withValidation(
+  p.basename(dir.path).substring(profileDirPrefix.length),
+);
+
+Directory getProfileDir(Directory profilesDir, UuidValue profileUuid) {
+  return Directory(
+    p.join(profilesDir.path, '$profileDirPrefix${profileUuid.uuid}'),
+  );
+}
+
+Future<Profile?> readProfileMetadata(Directory profileDir) async {
+  final file = File(p.join(profileDir.path, _metadataFile));
+  if (!await file.exists()) {
+    return null;
+  }
+
+  final content = await file.readAsString();
+  return Profile.fromJson(jsonDecode(content) as Map<String, dynamic>);
+}
+
+Future<void> writeProfileMetadata(Directory profileDir, Profile profile) async {
+  final file = File(p.join(profileDir.path, _metadataFile));
+  await file.writeAsString(jsonEncode(profile.toJson()), flush: true);
+}
+
+Future<bool> createNewProfile(Directory profilesDir, Profile profile) async {
+  final profileDir = getProfileDir(profilesDir, profile.uuidValue);
+
+  if (await profileDir.exists()) {
+    return false;
+  }
+  await profileDir.create();
+  await writeProfileMetadata(profileDir, profile);
+
+  return true;
+}
+
+Future<List<Directory>> sortByAccessTime(
+  List<Directory> dirs, {
+  bool descending = true,
+}) async {
+  final dirsWithStats = await Future.wait(
+    dirs.map((dir) async {
+      final stat = await dir.stat();
+      return (dir: dir, accessed: stat.accessed);
+    }),
+  );
+
+  dirsWithStats.sort((a, b) {
+    final comparison = a.accessed.compareTo(b.accessed);
+    return descending ? -comparison : comparison;
+  });
+
+  return dirsWithStats.map((record) => record.dir).toList();
+}