Files
archived-camoufox/browser/scripts/package.py
T
coffeegrind123andClaude Opus 5.5 4db36c3ae3 Give packaged font files ASCII names
The font bundle carries macOS faces named in Japanese (Hiragino). The
zip stores them correctly as UTF-8, but unzip 6.0 under a C/POSIX
locale -- a Docker build, a bare SSH shell -- calls each a mismatching
local filename and exits 1, which stops every consumer's `set -e`
install. Packaging now keeps the ASCII part of a non-ASCII file name
and replaces the rest with a digest of the original; nothing reads a
font by file name.

Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
2026-10-18 09:52:54 +03:00

275 lines
11 KiB
Python

#!/usr/bin/env python3
import argparse
import glob
import hashlib
import json
import os
import shutil
import sys
import tempfile
from shlex import join
from _mixin import find_src_dir, get_moz_target, list_files, run, temp_cd
# The GPU probe (gfxtest) is NOT here: without it nsIGfxInfo has no data and the
# driver blocklist refuses every WebGL context where stock Firefox gets one.
UNNEEDED_PATHS = {'uninstall', 'pingsender.exe', 'pingsender'}
def inject_locales(target_dir, target, version, src_dir):
"""Bake the official language packs in as packaged locales.
Without them a spoofed non-English locale localizes Intl/number/date
formatting but leaves every browser-provided string that content can read
(input.validationMessage, XML parse errors) in English -- a mix no real
Firefox produces. A langpack add-on does not fix it: the parent pre-creates
those string bundles before add-ons start. Packaged locales are what a
Mozilla localized build has, selected by intl.locale.requested (pythonlib).
"""
langpacks = os.path.join('bundle', 'langpacks')
version_file = os.path.join(langpacks, 'VERSION')
base_version = version.split('-')[0]
have = open(version_file).read().strip() if os.path.exists(version_file) else None
if have != base_version:
# Not in git (bundle/langpacks is ignored): fetch them from
# archive.mozilla.org the way `make fetch` fetches the source.
run(join([sys.executable, os.path.join('scripts', 'fetch-langpacks.py'), base_version]))
have = open(version_file).read().strip() if os.path.exists(version_file) else None
if have != base_version:
raise FileNotFoundError(
f"bundle/langpacks is for Firefox {have}, need {base_version}: "
f"run scripts/fetch-langpacks.py {base_version}"
)
# Mozilla's macOS Japanese build is ja-JP-mac; every other platform ships ja.
skip = 'ja' if target == 'macos' else 'ja-JP-mac'
xpis = sorted(
path for path in glob.glob(os.path.join(langpacks, '*.xpi'))
if os.path.basename(path)[:-4] != skip
)
run(join([sys.executable, os.path.join('scripts', 'inject-locales.py'),
'--source-tree', src_dir, target_dir, *xpis]))
def font_groups_for(groups_file, oses):
"""Group directories the named OSes read."""
if not os.path.exists(groups_file):
raise FileNotFoundError(f'{groups_file} is missing: run `make fonts-extract`')
with open(groups_file, encoding='utf-8') as fh:
read_by = json.load(fh).get('readBy', {})
key = {'linux': 'lin', 'macos': 'mac', 'windows': 'win'}
out = set()
for o in oses:
out.update(read_by.get(key.get(o, o), []))
return sorted(out)
def ascii_file_names(root):
"""Rename every file under `root` whose name is not ASCII.
The release zip is extracted with `unzip`, and unzip 6.0 under a C/POSIX
locale (a Docker build, a bare SSH shell) reports each UTF-8 name as a
"mismatching local filename" and exits 1, stopping the consumer's install
-- though the zip stores the names correctly. The font bundle's Hiragino
faces are named in Japanese. Nothing reads a font by its file name
(fontconfig and the flat CoreText/DirectWrite directories take family names
from the font itself), so the ASCII part of the name is kept and the rest
replaced by a short digest of the original: stable across builds, unique.
"""
for dirpath, _, files in os.walk(root):
for name in files:
if name.isascii():
continue
stem, ext = os.path.splitext(name)
kept = ''.join(c for c in stem if c.isascii() and (c.isalnum() or c in '_-')).rstrip('_-')
digest = hashlib.sha256(name.encode('utf-8')).hexdigest()[:12]
ascii_name = f"{kept}_u{digest}{ext if ext.isascii() else ''}"
os.rename(os.path.join(dirpath, name), os.path.join(dirpath, ascii_name))
def add_includes_to_package(package_file, includes, fonts, new_file, target, version, src_dir):
with tempfile.TemporaryDirectory() as temp_dir:
# Extract package
run(join(['7z', 'x', package_file, f'-o{temp_dir}']), exit_on_fail=False)
# Delete package_file
os.remove(package_file)
if package_file.endswith('.tar.xz'):
# Rerun on the tar file
package_tar = package_file[:-3] # Remove ".xz"
return add_includes_to_package(
package_file=os.path.join(temp_dir, package_tar),
includes=includes,
fonts=fonts,
new_file=new_file,
target=target,
version=version,
src_dir=src_dir,
)
if target == 'macos':
# Move Camoufox/Camoufox.app -> Camoufox.app
nightly_dir = os.path.join(temp_dir, 'Camoufox')
shutil.move(
os.path.join(nightly_dir, 'Camoufox.app'), os.path.join(temp_dir, 'Camoufox.app')
)
# Remove old app dir and all content in it
shutil.rmtree(nightly_dir)
else:
# Move contents out of camoufox folder if it exists
old_camoufox_dir = os.path.join(temp_dir, 'camoufox')
camoufox_dir = os.path.join(temp_dir, 'camoufox-folder')
if os.path.exists(old_camoufox_dir):
# Rename camoufox_dir
os.rename(old_camoufox_dir, camoufox_dir)
for item in os.listdir(camoufox_dir):
shutil.move(os.path.join(camoufox_dir, item), temp_dir)
os.rmdir(camoufox_dir)
# Create target_dir
if target == 'macos':
target_dir = os.path.join(temp_dir, 'Camoufox.app', 'Contents', 'Resources')
else:
target_dir = temp_dir
# Add includes. A missing one is fatal: an unexpanded MSVC CRT glob used to
# be skipped, shipping a browser that needs the redistributable installed.
missing = [include for include in includes or [] if not os.path.exists(include)]
if missing:
raise FileNotFoundError(
"Missing --includes entries (unexpanded glob or wrong path):\n "
+ "\n ".join(missing)
)
for include in includes or []:
if os.path.isdir(include):
shutil.copytree(
include,
os.path.join(target_dir, os.path.basename(include)),
dirs_exist_ok=True,
)
else:
shutil.copy2(include, target_dir)
# Add the fonts under fonts/. The bundle stores each face once per OS set
# (bundle/fonts/groups.json), so look up the groups each OS reads.
fonts_dir = os.path.join(target_dir, 'fonts')
groups_file = os.path.join('bundle', 'fonts', 'groups.json')
wanted = font_groups_for(groups_file, fonts or [])
if target == 'linux':
# Linux resolves fonts through fontconfig, which is handed the exact
# group directories for the claimed OS at launch (utils._generate_fontconfig),
# so the subdirectories are the per-OS gate and must be preserved.
for g in wanted:
shutil.copytree(os.path.join('bundle', 'fonts', g),
os.path.join(fonts_dir, g), dirs_exist_ok=True)
shutil.copy2(groups_file, os.path.join(fonts_dir, 'groups.json'))
else:
# macOS (CoreText) and Windows (DirectWrite) activate ONE flat
# directory and cannot read subfolders, so there is no directory
# gate on those targets -- the font allowlist is what restricts a
# lookup (font-hijacker.patch). Flatten, skipping any face whose
# bytes are already present.
os.makedirs(fonts_dir, exist_ok=True)
seen = set()
for g in wanted:
for file in list_files(root_dir=os.path.join('bundle', 'fonts', g), suffix='*'):
with open(file, 'rb') as fh:
digest = hashlib.sha256(fh.read()).hexdigest()
if digest in seen:
continue
seen.add(digest)
shutil.copy2(file, os.path.join(fonts_dir, os.path.basename(file)))
if os.path.isdir(fonts_dir):
ascii_file_names(fonts_dir)
inject_locales(target_dir, target, version, src_dir)
# Remove unneeded paths
for path in UNNEEDED_PATHS:
if os.path.isdir(os.path.join(target_dir, path)):
shutil.rmtree(os.path.join(target_dir, path), ignore_errors=True)
elif os.path.exists(os.path.join(target_dir, path)):
os.remove(os.path.join(target_dir, path))
# Update package
run(join(['7z', 'u', new_file, f'{temp_dir}/*', '-r', '-mx=9']))
def get_args():
"""Get CLI parameters"""
parser = argparse.ArgumentParser(
description='Package Camoufox for different operating systems.'
)
parser.add_argument('os', choices=['linux', 'macos', 'windows'], help='Target operating system')
parser.add_argument(
'--includes', nargs='+', help='List of files or directories to include in the package'
)
parser.add_argument('--version', required=True, help='Camoufox version')
parser.add_argument('--release', required=True, help='Camoufox release number')
parser.add_argument(
'--arch', choices=['x86_64', 'i686', 'arm64'], help='Architecture for Windows build'
)
parser.add_argument('--fonts', nargs='+', help='Font directories to include under fonts/')
return parser.parse_args()
def main():
"""The main packaging function"""
args = get_args()
# Determine file extension based on OS
file_extensions = {'linux': 'tar.xz', 'macos': 'dmg', 'windows': 'zip'}
file_ext = file_extensions[args.os]
# Build the package
src_dir = find_src_dir('.', args.version, args.release)
moz_target = get_moz_target(target=args.os, arch=args.arch)
with temp_cd(src_dir):
# Create package files
run('./mach package')
# Find package files
search_path = os.path.abspath(
f'obj-{moz_target}/dist/camoufox-{args.version}-{args.release}.*.{file_ext}'
)
# Copy package files
for file in glob.glob(search_path):
if 'xpt_artifacts' in file:
print(f'Skipping xpt artifacts: {file}')
continue
print(f'Found package: {file}')
# Copy to root
shutil.copy2(file, '.')
break
else:
print(f"Error: No package file found matching pattern: {search_path}")
sys.exit(1)
# Find the package file
package_pattern = f'camoufox-{args.version}-{args.release}.en-US.*.{file_ext}'
package_files = glob.glob(package_pattern)
if not package_files:
print(f"Error: No package file found matching pattern: {package_pattern}")
exit(1)
package_file = package_files[0]
# Add includes to the package
new_name = f'camoufox-{args.version}-{args.release}-{args.os[:3]}.{args.arch}.zip'
add_includes_to_package(
package_file=package_file,
includes=args.includes,
fonts=args.fonts,
new_file=new_name,
target=args.os,
version=args.version,
src_dir=os.path.abspath(src_dir),
)
print(f"Packaging complete for {args.os}")
if __name__ == '__main__':
main()