Skip to content

Make videos on the computer you already own. FreeVideo runs MiniMax H3 in as little as 8 GB of VRAM and 16 GB of RAM, and adapts its acceleration path to your hardware.

10.3 KB
Raw Blame
"""Explicit, authenticated small updates; unavailable deltas fall back to EXEs."""
import logging
import os
from pathlib import Path
import re
import shutil
import sys

from . import disk_space, execution_paths, network
from . import launcher_update as update
from .top_level_modules import update_modules

ed25519, keys, source = update_modules()

log = logging.getLogger(__name__)
DOMAIN = b'FreeVideo source manifest v1\x00'


def signed(value):
    return source.signed(value)


def metadata_name(candidate):
    version = candidate.get('product_version')
    if not source.VERSION.fullmatch(str(version)):
        raise ValueError('Source updates require a product version')
    return 'source-%s-%s.json' % (version, update.build_target(candidate))


def read_metadata(url, token, *, github=False, limit=source.MAX_MANIFEST):
    with update.open_download(url, token, binary=True, github_only=github) as response:
        return b''.join(update._bytes(response, limit))


def same_build(first, second):
    first, second = update.build_identity(first), update.build_identity(second)
    # publish_release may trim older notes to stay under the 64 KiB legacy cap.
    return all(first.get(key, default) == second.get(key, default) for key, default in (
        ('schema', None), ('repository', None), ('channel', None), ('target', 'windows-x86_64'),
        ('packaging', None), ('track', 'stable'), ('revision', None), ('built_at', None),
        ('version', None), ('product_version', None)))


def fetch_manifest(candidate, token=''):
    """Never infer source trust from cached/remote _update_sources flags."""
    name = metadata_name(candidate)
    github = update.asset_url('v' + candidate['product_version'], name)
    try:
        digest = read_metadata(github + '.sha256', token, github=True, limit=65).decode('ascii').strip()
        if not source.HEX.fullmatch(digest):
            raise ValueError('Invalid GitHub source digest')
        data = read_metadata(github, token, github=True)
        if source.sha(data) != digest:
            raise ValueError('GitHub source digest mismatch')
        value = source.manifest(source.decode(data))
    except (OSError, ValueError, TypeError):
        # Mirrors may host a signed manifest, but a public RFC test key cannot
        # authorize anything. Fail quickly before fetching when still disabled.
        if not keys.ED25519_RELEASE_KEY_ENABLED or keys.ED25519_PUBLIC_KEY == keys.PLACEHOLDER_PUBLIC_KEY:
            raise ValueError('No authenticated source manifest') from None
        data = read_metadata(update.mirror_url('releases/v' + candidate['product_version'] + '/' + name), '')
        value = source.manifest(source.decode(data))
        if not signed(value):
            raise ValueError('Invalid source signature')
    if not same_build(value['build'], candidate):
        raise ValueError('Source manifest belongs to another release')
    return value


def pending_path(home, candidate):
    return source.io_path(home) / 'updates' / ('source-' + candidate['revision'] + '.json')


def try_download(candidate, home, token='', *, progress=None, cancel=None, language=None):
    context = source.bundle_context()
    if context is None or update.build_track(candidate) != 'stable':
        return None
    base, bundle = context
    active = source.ACTIVE
    previous = active['manifest'] if active else base
    current_source = active['source'] if active else bundle
    try:
        def cancelled():
            if cancel is not None and cancel.is_set():
                raise InterruptedError('Source update cancelled')
        cancelled()
        source.storage(source.io_path(home))
        value = fetch_manifest(candidate, token)
        delta = value.get('delta')
        if (not update.newer(value['build'], previous['build']) or not source.compatible(value, base) or
                not delta or delta['from'] != previous['identity'] or
                (not value['gui'] and value.get('launcher_files_changed', True))):
            return None
        target = source.io_path(home) / 'updates' / delta['sha256'] / delta['name']
        # Sparse overlay + complete composed tree + unzip buffer + download.
        needed = delta['bytes'] + 3*sum(row['bytes'] for row in value['files'].values()) + 16*2**20
        if disk_space.free_bytes(target.parent) < needed:
            raise update.UpdateUnavailable('disk')
        sources = {'github': update.asset_url('v' + candidate['product_version'], delta['name']),
                   'mirror': update.mirror_url('releases/v' + candidate['product_version'] + '/' + delta['name'])}
        candidates = [(name, sources[name]) for name in update.source_order(language)]
        def report(done, total, speed):
            cancelled()
            if progress:
                progress(dict(done=done, total=total, bytes_per_second=speed,
                              remaining_seconds=(total-done)/speed if speed > 0 else 0))
        network.download(candidates, target, delta['sha256'], report,
                         network=dict(quiet=True, resource_check=cancelled), size=delta['bytes'],
                         category='launcher-update', cycles=1, stall_seconds=update.UPDATE_STALL_SECONDS,
                         low_speed_limit=0, validate_url=update._trusted_url)
        cancelled()
        folder = source.prepare(value, previous, bundle, current_source, target, home, base)
        cancelled()
        source.atomic_json(pending_path(home, candidate), {'overlay': folder.name, 'identity': value['identity']})
        return folder
    except InterruptedError:
        raise
    except Exception as error:
        # No paths, metadata, response bodies or credentials enter diagnostics.
        log.info('Source update unavailable; using full package (%s)', type(error).__name__)
        try:
            pending_path(home, candidate).unlink(missing_ok=True)
        except OSError:
            pass
        return None


def prepared(candidate, home):
    context = source.bundle_context()
    if context is None:
        return None
    base, bundle = context
    path = pending_path(home, candidate)
    if not path.exists():
        return None
    try:
        receipt = source.read_json(path)
        name = receipt['overlay']
        if not re.fullmatch(r'\d+\.\d+\.\d+-[0-9a-f]{16}', name):
            raise ValueError('Invalid overlay name')
        folder = source.io_path(home) / 'overlay' / name
        value = source.validate_overlay(folder, base)
        if (receipt['identity'] != value['identity'] or
                not same_build(value['build'], candidate)):
            raise ValueError('Prepared source identity changed')
        source.compose(bundle, folder, value, source.io_path(home) / 'source-overlay')
        return folder
    except (OSError, ValueError, KeyError, TypeError):
        path.unlink(missing_ok=True)
        raise update.DownloadedLauncherUnavailable('Prepared source changed; download again') from None


def cleanup(home, keep):
    """Only remove validated, updater-owned obsolete directories; never user trees."""
    home = source.io_path(home)
    for folder in (home / 'overlay').iterdir():
        if folder.name in keep or not re.fullmatch(r'\d+\.\d+\.\d+-[0-9a-f]{16}', folder.name):
            continue
        # Another launcher may still be running from this version.
        if source.in_use(home, folder.name):
            continue
        try:
            if folder.is_symlink() or {p.name for p in folder.iterdir()} != {'receipt.json', 'files'}:
                continue
            receipt = source.read_json(folder / 'receipt.json')
            value = source.manifest(receipt['manifest'])
            if source.overlay_name(value) != folder.name or receipt['sha256'] != source.sha(source.canonical(value)):
                continue
            composed = home / 'source-overlay' / folder.name
            if composed.exists():
                source.verify_tree(composed, value['files'])
                shutil.rmtree(composed)
            # An edited overlay is retained for inspection, never executed.
            files = folder / 'files'
            for path in files.rglob('*'):
                if path.is_symlink():
                    raise ValueError('Changed overlay')
                if path.is_file():
                    name = path.relative_to(files).as_posix()
                    source.verify_file(path, value['files'][name])
            shutil.rmtree(folder)
        except (OSError, ValueError, KeyError, TypeError):
            continue


def launch(candidate, home, folder, *, token='', popen=None):
    home = source.io_path(home)
    active_path = home / 'overlay' / 'active.json'
    try:
        old = source.read_json(active_path)
    except (OSError, ValueError):
        old = {'entries': []}
    # Last actually running overlay is the rollback target, even after recovery.
    previous = source.ACTIVE['folder'].name if source.ACTIVE else None
    entries = [folder.name] + ([previous] if previous and previous != folder.name else [])
    from .linux_bundle import child_environment, appimage
    env = dict(child_environment(), FREEVIDEO_LAUNCHER_HOME=str(home), PYINSTALLER_RESET_ENVIRONMENT='1')
    if token:
        env['GITHUB_TOKEN'] = token
    executable = str(appimage() or sys.executable)
    kwargs = dict(cwd=Path(executable).parent, env=env, close_fds=True)
    if os.name == 'nt':
        kwargs['creationflags'] = subprocess_flags()
    else:
        kwargs['start_new_session'] = True
    executable_receipt = home / 'updates' / 'active.json'
    try:
        old_executable = source.read_json(executable_receipt)
    except (OSError, ValueError):
        old_executable = None
    source.atomic_json(active_path, {'entries': entries})
    try:
        # Let the established handoff/resume path finish installing the engine.
        update.save(home / 'updates' / 'active.json', dict(approved=True, candidate=update.manifest(candidate)))
        process = (popen or execution_paths.popen)([executable], **kwargs)
    except BaseException:
        source.atomic_json(active_path, old)
        if old_executable is None:
            executable_receipt.unlink(missing_ok=True)
        else:
            source.atomic_json(executable_receipt, old_executable)
        raise
    try:
        cleanup(home, set(entries))
    except OSError:
        pass
    return process


def subprocess_flags():
    import subprocess
    return subprocess.DETACHED_PROCESS | subprocess.CREATE_NEW_PROCESS_GROUP