Files
archived-camoufox/pythonlib/camoufox/gui/backend.py
T
luandhgt b2d842177a Verify sha256 of downloaded release assets before extracting
check_asset() already reads the asset's digest from the GitHub API and
stores it as installed_sha256, and AvailableVersion carries a sha256
field through to version.json. Nothing compared either against the
bytes that were downloaded: every sha256 equality check in the package
compares metadata to metadata when selecting an installed version, and
hashlib appeared only in utils.py to key a config cache.

So the archive that gets extracted over the install directory, and then
chmod 755'd and executed, was accepted on transport security alone. The
digest needed to catch a substituted or truncated asset was already in
hand and unused.

Add verify_sha256() and call it between download and extraction on both
install paths -- install_versioned() for the CLI and InstallWorker for
the GUI. It hashes in 1 MiB blocks so a multi-hundred-megabyte asset
does not have to be held in memory, and rewinds the buffer afterwards
so unzip() still reads from the start.

When no digest is published the install proceeds with a warning rather
than failing: some sources publish no digest, and refusing to install
from them would be a regression, not a fix.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
(cherry picked from commit 65cda21b4f)
2026-09-05 14:26:37 -06:00

1255 lines
39 KiB
Python

import os
import sys
import tempfile
from enum import IntEnum
from pathlib import Path
from PySide6.QtCore import (
Property,
QAbstractListModel,
QModelIndex,
QObject,
Qt,
QThread,
QUrl,
Signal,
Slot,
)
from PySide6.QtGui import QGuiApplication, QIcon
from PySide6.QtQml import QQmlApplicationEngine
from PySide6.QtQuickControls2 import QQuickStyle
from ..multiversion import (
BROWSERS_DIR,
get_cached_versions,
get_default_channel,
get_repo_name,
list_installed,
load_config,
load_repo_cache,
remove_version,
save_config,
save_repo_cache,
set_active,
)
from ..pkgman import RepoConfig, unzip, verify_sha256, webdl
# Workers
class Worker(QThread):
progress = Signal(float)
status = Signal(str)
done = Signal(bool, str)
def _progress(self, downloaded, total):
if total > 0:
self.progress.emit(downloaded / total)
class DownloadWorker(Worker):
def __init__(self, repo_config, version, activate_after_install=False):
super().__init__()
self.repo_config = repo_config
self.version = version
self.activate_after_install = activate_after_install
self.relative_path = None
def run(self):
try:
import shlex
import orjson
from ..multiversion import version_folder_name
self.status.emit("Downloading...")
repo_name = get_repo_name(self.repo_config.repo)
sha8 = self.version.sha8 if self.version.sha256 else ""
folder = version_folder_name(
self.version.version.version, self.version.version.build, sha8
)
path = BROWSERS_DIR / repo_name / folder
path.mkdir(parents=True, exist_ok=True)
with tempfile.NamedTemporaryFile() as f:
webdl(self.version.url, buffer=f, bar=False, progress_callback=self._progress)
self.status.emit("Verifying...")
self.progress.emit(-1)
verify_sha256(
f, self.version.sha256, desc=f"Camoufox v{self.version.version.full_string}"
)
self.status.emit("Extracting...")
unzip(f, str(path), bar=False)
(path / 'version.json').write_bytes(orjson.dumps(self.version.to_metadata()))
if sys.platform != 'win32':
os.system(f'chmod -R 755 {shlex.quote(str(path))}')
self.relative_path = f"browsers/{repo_name}/{folder}"
self.done.emit(True, f"Installed v{self.version.version.full_string}")
except Exception as e:
msg = str(e)
if '404' in msg or 'Not Found' in msg:
self.done.emit(False, "Release not found (404). Please resync.")
else:
self.done.emit(False, msg)
class SyncWorker(Worker):
def __init__(self, spoof_os=None, spoof_arch=None, spoof_lib_ver=None):
super().__init__()
self.spoof_os = spoof_os
self.spoof_arch = spoof_arch
self.spoof_lib_ver = spoof_lib_ver
def run(self):
try:
from datetime import datetime
from ..pkgman import list_available_versions
self.status.emit("Syncing...")
cache = {'repos': []}
for rc in RepoConfig.load_repos(spoof_library_version=self.spoof_lib_ver):
self.status.emit(f"Syncing {rc.name}...")
versions = list_available_versions(
rc,
include_prerelease=True,
spoof_os=self.spoof_os,
spoof_arch=self.spoof_arch,
)
cache['repos'].append(
{
'name': rc.name,
'repo': rc.repo,
'versions': [
{
'version': v.version.version,
'build': v.version.build,
'url': v.url,
'is_prerelease': v.is_prerelease,
'asset_id': v.asset_id,
'asset_size': v.asset_size,
'asset_updated_at': v.asset_updated_at,
'sha256': v.sha256,
'created_at': v.asset_created_at,
}
for v in versions
],
}
)
cache['spoof_os'] = self.spoof_os
cache['spoof_arch'] = self.spoof_arch
cache['spoof_lib_ver'] = self.spoof_lib_ver
_dfmt = '%#m/%#d/%Y %#I:%M %p' if sys.platform == 'win32' else '%-m/%-d/%Y %-I:%M %p'
cache['sync_time'] = datetime.now().strftime(_dfmt)
save_repo_cache(cache)
total = sum(len(r['versions']) for r in cache['repos'])
self.done.emit(True, f"Synced {total} versions")
except Exception as e:
self.done.emit(False, str(e))
class GeoIPWorker(Worker):
def __init__(self, source):
super().__init__()
self.source = source
def run(self):
try:
from ..geolocation import download_mmdb
download_mmdb(source=self.source, progress_callback=self._progress)
self.done.emit(True, f"Installed: {self.source}")
except Exception as e:
self.done.emit(False, str(e))
# Models
class Roles(IntEnum):
Display = Qt.ItemDataRole.UserRole + 1
Build = Qt.ItemDataRole.UserRole + 2
IsHeader = Qt.ItemDataRole.UserRole + 3
IsPrerelease = Qt.ItemDataRole.UserRole + 4
IsActive = Qt.ItemDataRole.UserRole + 5
IsInstalled = Qt.ItemDataRole.UserRole + 6
Section = Qt.ItemDataRole.UserRole + 7
Expanded = Qt.ItemDataRole.UserRole + 8
IsPinned = Qt.ItemDataRole.UserRole + 9
Date = Qt.ItemDataRole.UserRole + 10
Note = Qt.ItemDataRole.UserRole + 11
_ROLE_ATTRS = {
Roles.Display: 'display',
Roles.Build: 'build',
Roles.IsHeader: 'is_header',
Roles.IsPrerelease: 'is_prerelease',
Roles.IsActive: 'is_active',
Roles.IsInstalled: 'is_installed',
Roles.Section: 'section',
Roles.Expanded: 'expanded',
Roles.IsPinned: 'is_pinned',
Roles.Date: 'date',
Roles.Note: 'note',
}
_BOOL_ROLES = {
Roles.IsHeader,
Roles.IsPrerelease,
Roles.IsActive,
Roles.IsInstalled,
Roles.Expanded,
Roles.IsPinned,
}
_ROLE_NAMES = {
Roles.Display: b"display",
Roles.Build: b"build",
Roles.IsHeader: b"isHeader",
Roles.IsPrerelease: b"isPrerelease",
Roles.IsActive: b"isActive",
Roles.IsInstalled: b"isInstalled",
Roles.Section: b"section",
Roles.Expanded: b"expanded",
Roles.IsPinned: b"isPinned",
Roles.Date: b"date",
Roles.Note: b"note",
}
class VersionItem:
__slots__ = (
'display',
'build',
'is_header',
'is_prerelease',
'is_active',
'is_pinned',
'is_installed',
'section',
'expanded',
'version_data',
'installed_data',
'date',
'note',
)
def __init__(
self,
display,
build="",
is_header=False,
is_prerelease=False,
is_active=False,
is_pinned=False,
is_installed=False,
section="",
expanded=True,
version_data=None,
installed_data=None,
date="",
note="",
):
self.display = display
self.build = build
self.is_header = is_header
self.is_prerelease = is_prerelease
self.is_active = is_active
self.is_pinned = is_pinned
self.is_installed = is_installed
self.section = section
self.expanded = expanded
self.version_data = version_data
self.installed_data = installed_data
self.date = date
self.note = note
class VersionModel(QAbstractListModel):
def __init__(self, parent=None):
super().__init__(parent)
self._items = []
def rowCount(self, parent=QModelIndex()):
return len(self._items)
def data(self, index, role=Qt.ItemDataRole.DisplayRole):
if not index.isValid() or index.row() >= len(self._items):
return False if role in _BOOL_ROLES else ""
attr = _ROLE_ATTRS.get(role)
return getattr(self._items[index.row()], attr, "") if attr else ""
def roleNames(self):
return _ROLE_NAMES
def set_items(self, items):
self.beginResetModel()
self._items = items
self.endResetModel()
def get(self, index):
return self._items[index] if 0 <= index < len(self._items) else None
OS_OPTIONS = ["(auto)", "mac", "win", "lin"]
ARCH_OPTIONS = ["(auto)", "x86_64", "i686", "arm64"]
# Backend
class Backend(QObject):
reposChanged = Signal()
busyChanged = Signal()
progressChanged = Signal()
statusChanged = Signal()
selectionChanged = Signal()
geoipChanged = Signal()
infoChanged = Signal()
debugChanged = Signal()
currentRepoChanged = Signal()
channelPrompt = Signal(int, str, str)
installedPrompt = Signal(int, str, str, bool, str)
def __init__(self):
super().__init__()
self._repo_configs = list(RepoConfig.load_repos())
self._repos = [r.name for r in self._repo_configs]
self._version_model = VersionModel(self)
self._current_repo = self._repo_configs[0] if self._repo_configs else None
self._selected = -1
self._busy = False
self._progress = -1.0
self._status_text = ""
self._status_color = "#888"
self._installed_only = False
self._sections = {"stable": True, "prerelease": True}
self._worker = None
self._channel_data = None
self._geoip_available = False
self._geoip_sources = []
self._geoip_names = []
self._geoip_installed = ""
self._geoip_downloaded = []
self._geoip_path = ""
self._geoip_size = ""
self._geoip_mtime = ""
self._geoip_busy = False
self._geoip_progress = -1.0
self._lookup_result = ""
self._lookup_ok = True
self._spoof_os_idx = 0
self._spoof_arch_idx = 0
self._spoof_lib_ver = ""
self._pending_channel = None
self._load_spoof_from_cache()
self._load_geoip()
# Properties
@Property(list, notify=reposChanged)
def repos(self):
return self._repos
@Property(QObject, constant=True)
def versionModel(self):
return self._version_model
@Property(bool, notify=busyChanged)
def busy(self):
return self._busy
@Property(float, notify=progressChanged)
def progress(self):
return self._progress
@Property(str, notify=statusChanged)
def statusText(self):
return self._status_text
@Property(str, notify=statusChanged)
def statusColor(self):
return self._status_color
@Property(bool, notify=selectionChanged)
def canInstall(self):
item = self._version_model.get(self._selected)
return item and not item.is_header and not item.is_installed
@Property(bool, notify=selectionChanged)
def canUninstall(self):
item = self._version_model.get(self._selected)
return item and not item.is_header and item.is_installed
@Property(str, notify=selectionChanged)
def selectedVersion(self):
item = self._version_model.get(self._selected)
return item.display if item else ""
@Property(bool, notify=selectionChanged)
def selectedIsPrerelease(self):
item = self._version_model.get(self._selected)
return item.is_prerelease if item else False
@Property(bool, notify=geoipChanged)
def geoipAvailable(self):
return self._geoip_available
@Property(list, notify=geoipChanged)
def geoipSources(self):
return self._geoip_sources
@Property(str, notify=geoipChanged)
def geoipInstalled(self):
return self._geoip_installed
@Property(list, notify=geoipChanged)
def geoipDownloaded(self):
return self._geoip_downloaded
@Property(str, notify=geoipChanged)
def geoipPath(self):
return self._geoip_path
@Property(str, notify=geoipChanged)
def geoipSize(self):
return self._geoip_size
@Property(str, notify=geoipChanged)
def geoipMtime(self):
return self._geoip_mtime
@Property(bool, notify=geoipChanged)
def geoipBusy(self):
return self._geoip_busy
@Property(float, notify=geoipChanged)
def geoipProgress(self):
return self._geoip_progress
@Property(str, notify=geoipChanged)
def lookupResult(self):
return self._lookup_result
@Property(bool, notify=geoipChanged)
def lookupSuccess(self):
return self._lookup_ok
@Property(str, notify=infoChanged)
def activeBrowserText(self):
cfg = load_config()
if cfg.get('pinned'):
return f"v{cfg['pinned']}"
channel = cfg.get('channel') or get_default_channel()
_, keys, latest = self._build_channels()
try:
return latest[keys.index(channel)] or channel
except ValueError:
return channel
@Property(str, notify=infoChanged)
def activeBrowserColor(self):
return "#26a69a"
@Property(str, notify=infoChanged)
def followedChannel(self):
return load_config().get('channel') or get_default_channel()
@Property(list, notify=infoChanged)
def channels(self):
return self._build_channels()[0]
@Property(list, notify=infoChanged)
def channelKeys(self):
return self._build_channels()[1]
@Property(list, notify=infoChanged)
def channelLatest(self):
return self._build_channels()[2]
@Property(str, notify=infoChanged)
def activeBrowserLabel(self):
cfg = load_config()
return "Pinned Version" if cfg.get('pinned') else "Active Channel"
@Property(str, notify=infoChanged)
def activeLabel(self):
cfg = load_config()
pinned = cfg.get('pinned')
if pinned:
return f"Pinned version: v{pinned}"
channel = cfg.get('channel') or get_default_channel()
parts = channel.split('/', 1)
repo = parts[0].capitalize()
ctype = parts[1] if len(parts) > 1 else 'stable'
if ctype == 'stable':
return f"Following channel: {repo}"
return f"Following channel: {repo}/{ctype}"
@Property(str, notify=infoChanged)
def libraryVersion(self):
return self._pkg_version('camoufox')
@Property(str, notify=infoChanged)
def playwrightVersion(self):
return self._pkg_version('playwright')
@Property(str, notify=infoChanged)
def browserforgeVersion(self):
return self._pkg_version('browserforge')
@Property(str, notify=infoChanged)
def fingerprintVersion(self):
return self._pkg_version('apify_fingerprint_datapoints')
@Property(str, notify=infoChanged)
def lastSyncTime(self):
cache = load_repo_cache()
raw = cache.get('sync_time') if cache else None
if not raw:
return ""
try:
from datetime import datetime
dt = datetime.strptime(raw, '%Y-%m-%d %H:%M')
_dfmt = '%#m/%#d/%Y %#I:%M %p' if sys.platform == 'win32' else '%-m/%-d/%Y %-I:%M %p'
return dt.strftime(_dfmt)
except ValueError:
return raw
@Property(str, notify=infoChanged)
def reposInfo(self):
cache = load_repo_cache()
if not cache:
return "Run sync"
repos = cache.get('repos', [])
total = sum(len(r.get('versions', [])) for r in repos)
return f"{len(repos)} repos, {total} versions"
@Property(list, constant=True)
def spoofOsOptions(self):
return OS_OPTIONS
@Property(list, constant=True)
def spoofArchOptions(self):
return ARCH_OPTIONS
@Property(int, notify=debugChanged)
def spoofOsIndex(self):
return self._spoof_os_idx
@Property(int, notify=debugChanged)
def spoofArchIndex(self):
return self._spoof_arch_idx
@Property(str, notify=debugChanged)
def spoofLibVer(self):
return self._spoof_lib_ver
@Property(int, notify=currentRepoChanged)
def currentRepoIndex(self):
if self._current_repo:
for i, rc in enumerate(self._repo_configs):
if rc.name == self._current_repo.name:
return i
return 0
# Internal
@staticmethod
def _pkg_version(pkg):
try:
from importlib.metadata import version
return version(pkg)
except Exception:
return "?"
def _build_channels(self):
"""
Build channel names, keys, and latest version strings (cached)
"""
if self._channel_data is not None:
return self._channel_data
cache = load_repo_cache()
channels, keys, latest = [], [], []
for rc in self._repo_configs:
repo_versions = []
if cache:
for repo in cache.get('repos', []):
if repo['name'].lower() == rc.name.lower():
repo_versions = repo.get('versions', [])
break
stable = [v for v in repo_versions if not v.get('is_prerelease')]
prereleases = [v for v in repo_versions if v.get('is_prerelease')]
channels.append(rc.name)
keys.append(rc.name)
latest.append(f"v{stable[0]['version']}-{stable[0]['build']}" if stable else "")
if prereleases:
channels.append(f"{rc.name} (Prerelease)")
keys.append(f"{rc.name}/prerelease")
latest.append(f"v{prereleases[0]['version']}-{prereleases[0]['build']}")
self._channel_data = (channels, keys, latest)
return self._channel_data
# Slots
@Slot(int)
def selectRepo(self, index):
if 0 <= index < len(self._repo_configs):
self._current_repo = self._repo_configs[index]
self._refresh()
@Slot(bool)
def setInstalledOnly(self, value):
self._installed_only = value
self._refresh()
@Slot(str)
def toggleSection(self, section):
self._sections[section] = not self._sections.get(section, True)
self._refresh()
@Slot(int)
def selectVersion(self, index):
self._selected = index
self.selectionChanged.emit()
@Slot(int)
def setActive(self, index):
item = self._version_model.get(index)
if not item or item.is_header or item.version_data is None:
return
cfg = load_config()
ctype = "prerelease" if item.is_prerelease else "stable"
cfg['channel'] = f"{get_repo_name(self._current_repo.repo)}/{ctype}"
cfg['pinned'] = f"{item.version_data.version.version}-{item.version_data.version.build}"
cfg['pinned_sha'] = item.version_data.sha256
cfg.update(
{
'active_repo': self._current_repo.name,
'active_build': item.version_data.version.build,
'active_version': item.version_data.version.version,
}
)
save_config(cfg)
if item.installed_data:
set_active(item.installed_data.relative_path)
self._refresh()
self.infoChanged.emit()
@Slot(int)
def unpinVersion(self, index):
item = self._version_model.get(index)
if not item or not item.is_pinned:
return
cfg = load_config()
cfg.pop('pinned', None)
cfg.pop('pinned_sha', None)
save_config(cfg)
self._refresh()
self.infoChanged.emit()
@Slot(int)
def followVersionChannel(self, index):
item = self._version_model.get(index)
if not item or not item.version_data or not item.installed_data:
return
ctype = "prerelease" if item.is_prerelease else "stable"
repo_name = self._current_repo.name
cfg = load_config()
cfg['channel'] = repo_name if ctype == "stable" else f"{repo_name}/{ctype}"
cfg.pop('pinned', None)
cfg.pop('pinned_sha', None)
cfg.update(
{
'active_repo': repo_name,
'active_build': item.version_data.version.build,
'active_version': item.version_data.version.version,
}
)
save_config(cfg)
set_active(item.installed_data.relative_path)
self._refresh()
self.infoChanged.emit()
@Slot(int)
def setFollowedChannel(self, index):
_, keys, _ = self._build_channels()
if not (0 <= index < len(keys)):
return
key = keys[index]
cfg = load_config()
cfg['channel'] = key
cfg.pop('pinned', None)
cfg.pop('pinned_sha', None)
repo_name, ctype = (key.split('/', 1) + ['stable'])[:2]
is_pre = ctype == 'prerelease'
display, build = "", ""
cache = load_repo_cache()
if cache:
for repo in cache.get('repos', []):
if repo['name'].lower() == repo_name.lower():
candidates = [
v for v in repo.get('versions', []) if v.get('is_prerelease') == is_pre
]
if candidates:
cfg['active_build'] = candidates[0]['build']
cfg['active_version'] = candidates[0]['version']
cfg['active_repo'] = repo_name
display = f"v{candidates[0]['version']}"
build = candidates[0]['build']
break
if not display:
return
# Send everything to pending until the prompt closes
self._pending_channel = (cfg, repo_name, is_pre)
self.channelPrompt.emit(-1, display, build)
@Slot()
def confirmFollowChannel(self):
if self._pending_channel is None:
return
cfg, repo_name, is_pre = self._pending_channel
self._pending_channel = None
save_config(cfg)
for rc in self._repo_configs:
if rc.name.lower() == repo_name.lower():
self._current_repo = rc
self.currentRepoChanged.emit()
break
self._refresh()
for idx, item in enumerate(self._version_model._items):
if item.is_header:
continue
if item.is_prerelease == is_pre:
if item.installed_data:
set_active(item.installed_data.relative_path)
self._refresh()
self._selected = idx
self.selectionChanged.emit()
break
self.infoChanged.emit()
@Slot()
def installSelected(self):
item = self._version_model.get(self._selected)
if item and not item.is_header and not item.is_installed:
worker = DownloadWorker(
self._current_repo,
item.version_data,
activate_after_install=item.is_active,
)
self._run_worker(worker, self._on_done)
@Slot()
def uninstallSelected(self):
item = self._version_model.get(self._selected)
if not item or not item.is_installed or not item.installed_data:
return
installed = item.installed_data
was_active = item.is_active
try:
remove_version(installed.path)
if was_active:
cfg = load_config()
cfg.update(
{
'active_repo': self._current_repo.name,
'active_build': installed.version.build,
'active_version': installed.version.version,
}
)
save_config(cfg)
self._set_status(f"Uninstalled {item.display}", "#2ecc71")
self._refresh()
self.infoChanged.emit()
except Exception as e:
self._set_status(str(e), "#e74c3c")
@Slot()
def refresh(self):
self._refresh()
self._set_status("Refreshed", "#888")
@Slot()
def sync(self):
spoof_os = OS_OPTIONS[self._spoof_os_idx] if self._spoof_os_idx > 0 else None
spoof_arch = ARCH_OPTIONS[self._spoof_arch_idx] if self._spoof_arch_idx > 0 else None
spoof_lib = self._spoof_lib_ver or None
self._run_worker(SyncWorker(spoof_os, spoof_arch, spoof_lib), self._on_done)
@Slot()
def cancelOperation(self):
if self._worker and self._worker.isRunning():
self._worker.terminate()
self._worker.wait()
self._busy = False
self._progress = -1
self.busyChanged.emit()
self._set_status("Cancelled", "#f39c12")
@Slot(str)
def downloadGeoip(self, source):
if not self._geoip_names or source not in self._geoip_names:
return
if source == self._geoip_installed:
from ..geolocation import needs_update
if not needs_update():
return
self._start_geoip_download(source)
@Slot()
def refreshGeoip(self):
if self._geoip_installed:
self._start_geoip_download(self._geoip_installed)
@Slot()
def deleteGeoipData(self):
from ..geolocation import remove_mmdb
remove_mmdb()
self._load_geoip()
@Slot(str)
def deleteGeoipSource(self, source):
from ..geolocation import MMDB_DIR, _get_geoip_config_by_name
try:
name = _get_geoip_config_by_name(source)['name'].lower()
for f in MMDB_DIR.glob(f"{name}-*.mmdb"):
f.unlink()
except Exception:
pass
self._load_geoip()
@Slot(str)
def setActiveGeoip(self, source):
from ..geolocation import _get_geoip_config_by_name, save_geoip_config
if source not in self._geoip_downloaded:
return
save_geoip_config(_get_geoip_config_by_name(source))
self._load_geoip()
@Slot(int)
def setSpoofOs(self, index):
self._spoof_os_idx = index
self.debugChanged.emit()
@Slot(int)
def setSpoofArch(self, index):
self._spoof_arch_idx = index
self.debugChanged.emit()
@Slot(str)
def setSpoofLibVer(self, ver):
self._spoof_lib_ver = ver.strip()
self.debugChanged.emit()
@Slot()
def openGeoipFolder(self):
from ..geolocation import MMDB_DIR
if not MMDB_DIR.exists():
return
import subprocess
path = str(MMDB_DIR)
if sys.platform == 'win32':
subprocess.Popen(['explorer', path])
elif sys.platform == 'darwin':
subprocess.Popen(['open', path])
else:
subprocess.Popen(['xdg-open', path])
@Slot(str)
def lookupIp(self, ip):
if not ip.strip():
self._lookup_result = "Enter IP"
self._lookup_ok = False
self.geoipChanged.emit()
return
try:
from ..geolocation import get_geolocation, get_mmdb_path
if not get_mmdb_path().exists():
self._lookup_result = "Database not downloaded"
self._lookup_ok = False
self.geoipChanged.emit()
return
geo = get_geolocation(ip.strip())
self._lookup_result = "<br>".join(
[
f"<b>Country:</b> {geo.locale.region}",
f"<b>TZ:</b> {geo.timezone}",
f"<b>Lat/Lon:</b> {geo.latitude:.4f}, {geo.longitude:.4f}",
]
)
self._lookup_ok = True
except Exception as e:
self._lookup_result = str(e)
self._lookup_ok = False
self.geoipChanged.emit()
# Internal helpers
def _load_geoip(self):
self._geoip_installed = ""
self._geoip_downloaded = []
self._geoip_path = ""
self._geoip_size = ""
self._geoip_mtime = ""
try:
from ..geolocation import (
ALLOW_GEOIP,
MMDB_DIR,
_load_geoip_repos,
get_mmdb_path,
load_geoip_config,
)
if not ALLOW_GEOIP:
self._geoip_available = False
self.geoipChanged.emit()
return
self._geoip_available = True
repos, _ = _load_geoip_repos()
self._geoip_names = self._geoip_sources = [r.get('name', '?') for r in repos]
if MMDB_DIR.exists():
for repo in repos:
nm = repo.get('name', '').lower()
if (MMDB_DIR / f"{nm}-combined.mmdb").exists() or (
MMDB_DIR / f"{nm}-ipv4.mmdb"
).exists():
self._geoip_downloaded.append(repo.get('name', ''))
config = load_geoip_config()
path = get_mmdb_path('ipv4', config)
if path.exists():
from datetime import datetime
self._geoip_installed = config.get('name', '')
self._geoip_path = str(path.parent)
stat = path.stat()
size = stat.st_size
if 'combined' not in config.get('urls', {}):
ipv6 = get_mmdb_path('ipv6', config)
if ipv6.exists():
size += ipv6.stat().st_size
self._geoip_size = f"{size / (1024 * 1024):.1f} MB"
self._geoip_mtime = datetime.fromtimestamp(stat.st_mtime).strftime('%Y-%m-%d %H:%M')
except Exception:
pass
self.geoipChanged.emit()
def _load_spoof_from_cache(self):
cache = load_repo_cache()
if not cache:
return
spoof_os = cache.get('spoof_os')
spoof_arch = cache.get('spoof_arch')
spoof_lib = cache.get('spoof_lib_ver')
if spoof_os and spoof_os in OS_OPTIONS:
self._spoof_os_idx = OS_OPTIONS.index(spoof_os)
if spoof_arch and spoof_arch in ARCH_OPTIONS:
self._spoof_arch_idx = ARCH_OPTIONS.index(spoof_arch)
if spoof_lib:
self._spoof_lib_ver = spoof_lib
def _refresh(self):
items = []
self._selected = -1
if not self._current_repo:
self._version_model.set_items(items)
return
from ..multiversion import classify_installs, get_repo_name
from ..pkgman import format_asset_date
cfg = load_config()
pinned = cfg.get('pinned')
pinned_sha = cfg.get('pinned_sha')
versions = get_cached_versions(self._current_repo.name)
if not versions:
self._version_model.set_items(items)
return
# newest sha per version-build, used when a pin has no specific sha
latest_sha = {}
for v in versions:
latest_sha.setdefault(v.version.full_string, v.sha256)
def _is_pinned(v):
if not pinned or pinned != v.version.full_string:
return False
if pinned_sha:
return v.sha256 == pinned_sha
return v.sha256 == latest_sha.get(v.version.full_string)
repo_key = get_repo_name(self._current_repo.repo)
channel = cfg.get('channel') or get_default_channel()
_, active_channel = (channel.split('/', 1) + ['stable'])[:2]
def _is_active(v, inst):
if inst and inst.is_active:
return True
return (
str(cfg.get('active_repo') or '').lower() == repo_key
and cfg.get('active_build') == v.version.build
and cfg.get('active_version') == v.version.version
and v.is_prerelease == (active_channel == 'prerelease')
and v.sha256 == latest_sha.get(v.version.full_string)
)
installed_list = [iv for iv in list_installed() if iv.repo_name == repo_key]
row_inst, extras = classify_installs(versions, installed_list)
inst_by_id = {id(v): inst for v, inst in zip(versions, row_inst)}
for section, is_prerelease in [("stable", False), ("prerelease", True)]:
version_list = [v for v in versions if v.is_prerelease == is_prerelease]
if not version_list:
continue
expanded = self._sections.get(section, True)
items.append(
VersionItem(
section.capitalize(),
is_header=True,
is_prerelease=is_prerelease,
section=section,
expanded=expanded,
)
)
if expanded:
for v in version_list:
inst = inst_by_id.get(id(v))
if self._installed_only and not inst:
continue
items.append(
VersionItem(
f"v{v.version.version}",
v.version.build,
is_prerelease=is_prerelease,
is_active=_is_active(v, inst),
is_pinned=_is_pinned(v),
is_installed=bool(inst),
version_data=v,
installed_data=inst,
date=format_asset_date(v.asset_created_at),
)
)
if extras:
expanded = self._sections.get("other", True)
items.append(
VersionItem(
"Other Installed",
is_header=True,
section="other",
expanded=expanded,
)
)
if expanded:
for iv, note in extras:
items.append(
VersionItem(
f"v{iv.version.version}",
iv.version.build,
is_prerelease=iv.is_prerelease,
is_active=iv.is_active,
is_installed=True,
version_data=None,
installed_data=iv,
date=format_asset_date(iv.created_at),
note=note,
)
)
self._version_model.set_items(items)
self.selectionChanged.emit()
def _set_status(self, text, color):
self._status_text = text
self._status_color = color
self.statusChanged.emit()
def _on_worker_progress(self, value):
self._progress = value
self.progressChanged.emit()
def _on_worker_status(self, status):
self._set_status(status, "#3498db")
def _on_geoip_progress(self, value):
self._geoip_progress = value
self.geoipChanged.emit()
def _on_geoip_status(self, status):
self.geoipChanged.emit()
def _run_worker(self, worker, done_callback):
self._busy = True
self._progress = -1
self.busyChanged.emit()
self._worker = worker
worker.progress.connect(self._on_worker_progress)
worker.status.connect(self._on_worker_status)
worker.done.connect(done_callback)
worker.start()
def _on_done(self, ok, msg):
worker = self._worker
self._busy = False
self._progress = -1
self.busyChanged.emit()
self._set_status(msg if ok else f"Error: {msg}", "#2ecc71" if ok else "#e74c3c")
if ok:
if (
isinstance(worker, DownloadWorker)
and worker.activate_after_install
and worker.relative_path
):
set_active(worker.relative_path)
self._channel_data = None
self._refresh()
if isinstance(worker, DownloadWorker):
target_idx = -1
for idx, item in enumerate(self._version_model._items):
version = item.version_data
if not version:
continue
if (
version.version.full_string == worker.version.version.full_string
and version.sha256 == worker.version.sha256
):
target_idx = idx
break
if target_idx >= 0:
self._selected = target_idx
self.selectionChanged.emit()
if not worker.activate_after_install:
versions = get_cached_versions(worker.repo_config.name)
latest = next(
(
version
for version in versions
if version.is_prerelease == worker.version.is_prerelease
),
None,
)
is_latest = bool(
latest
and latest.version.full_string == worker.version.version.full_string
and latest.sha256 == worker.version.sha256
)
channel = worker.repo_config.name
if worker.version.is_prerelease:
channel += " (Prerelease)"
item = self._version_model.get(target_idx)
self.installedPrompt.emit(
target_idx,
item.display,
item.build,
is_latest,
channel,
)
self.infoChanged.emit()
self._load_spoof_from_cache()
self.debugChanged.emit()
def _on_geoip_done(self, ok, msg):
self._geoip_busy = False
self._geoip_progress = -1
self._load_geoip()
def _start_geoip_download(self, source):
self._geoip_busy = True
self._geoip_progress = -1
self.geoipChanged.emit()
self._worker = GeoIPWorker(source)
self._worker.progress.connect(self._on_geoip_progress)
self._worker.status.connect(self._on_geoip_status)
self._worker.done.connect(self._on_geoip_done)
self._worker.start()
def main(debug=False):
QQuickStyle.setStyle("Basic")
# Suppress Breeze style warnings on KDE
from PySide6.QtCore import QtMsgType, qInstallMessageHandler
def _msg_filter(mode, ctx, msg):
if 'org/kde/breeze' in msg:
return
if mode in (QtMsgType.QtCriticalMsg, QtMsgType.QtFatalMsg):
print(msg, file=sys.stderr)
qInstallMessageHandler(_msg_filter)
app = QGuiApplication(sys.argv)
app.setWindowIcon(QIcon(str(Path(__file__).parent / "assets/icon.ico")))
engine = QQmlApplicationEngine()
engine.rootContext().setContextProperty("debugMode", debug)
backend = Backend()
backend.setParent(engine)
engine.rootContext().setContextProperty("backend", backend)
engine.load(QUrl.fromLocalFile(str(Path(__file__).parent / "qml/main.qml")))
if not engine.rootObjects():
sys.exit(-1)
ret = app.exec()
del engine
sys.exit(ret)