mirror of
https://github.com/daijro/camoufox.git
synced 2026-11-19 00:07:28 +00:00
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)
1255 lines
39 KiB
Python
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)
|