@minionry/minion 0.7.36

package/dist/server/services/browser/preflight.js

@@ -0,0 +1,590 @@
+// Copyright (c) 2025-present Minionry, Inc.
+// SPDX-License-Identifier: LicenseRef-Minionry-Software
+import { execFileSync } from 'node:child_process';
+import { existsSync, statSync } from 'node:fs';
+import { platform as osPlatform } from 'node:os';
+import { delimiter, join } from 'node:path';
+import { MINIONRY_ROOT } from '../../utils/paths.js';
+import { buildFixSteps, isSandboxConfigured, resolveChromeSandboxPath } from './chrome-sandbox.js';
+import { buildElectronRepairCommand } from './electron-provision.js';
+import { resolveDefaultAppDir, resolveDefaultElectronBinary } from './host-internal.js';
+import { parseChromiumSandboxMode, probablyInContainer } from './sandbox-policy.js';
+const PACTL_TIMEOUT_MS = 2_000;
+const LDD_TIMEOUT_MS = 3_000;
+const DEFAULT_SKIP_NOTE = 'Optional step skipped. The browser works without it.';
+export function buildSystemFixCommand(parts, pm) {
+    const required = parts.filter((p) => !p.optional).map((p) => p.fix);
+    const optional = parts.filter((p) => p.optional).map((p) => p.fix);
+    const installs = pm !== null && parts.some((p) => p.fix.packages.length > 0);
+    const steps = [];
+    if (installs && pm === 'apt')
+        steps.push('sudo apt-get update');
+    if (pm !== null && required.some((f) => f.packages.length > 0)) {
+        steps.push(installCommand(pm, required.map((f) => f.packages)));
+    }
+    steps.push(...required.flatMap((f) => f.steps));
+    for (const fix of optional) {
+        const inner = [
+            ...(pm !== null && fix.packages.length > 0 ? [installCommand(pm, [fix.packages], '      ')] : []),
+            ...fix.steps,
+        ];
+        if (inner.length === 0)
+            continue;
+        const note = fix.skipNote ?? DEFAULT_SKIP_NOTE;
+        steps.push(`{ ${inner.join(' && \\\n    ')} || \\\n    echo '${note}'; }`);
+    }
+    return steps.length > 0 ? steps.join(' && \\\n  ') : null;
+}
+function fixBlock(fix, pm, optional = false) {
+    const command = buildSystemFixCommand([{ fix, optional }], pm);
+    return command ? [command] : [];
+}
+const INSTALL_COMMAND = {
+    apt: 'sudo apt-get install -y',
+    dnf: 'sudo dnf install -y',
+    pacman: 'sudo pacman -S --needed --noconfirm',
+    apk: 'sudo apk add --no-cache',
+};
+const ONE_LINE_WIDTH = 72;
+const PACKAGE_LINE_WIDTH = 64;
+function installCommand(pm, groups, indent = '    ') {
+    const head = INSTALL_COMMAND[pm];
+    const seen = new Set();
+    const lines = groups.flatMap((group) => {
+        const fresh = group.filter((name) => !seen.has(name));
+        for (const name of fresh)
+            seen.add(name);
+        return wrapWords(fresh, PACKAGE_LINE_WIDTH);
+    });
+    const oneLine = `${head} ${lines.join(' ')}`;
+    if (oneLine.length <= ONE_LINE_WIDTH)
+        return oneLine;
+    return [head, ...lines].join(` \\\n${indent}`);
+}
+function wrapWords(words, width) {
+    const lines = [];
+    for (const word of words) {
+        const last = lines.length - 1;
+        if (last >= 0 && lines[last].length + 1 + word.length <= width)
+            lines[last] += ` ${word}`;
+        else
+            lines.push(word);
+    }
+    return lines;
+}
+function defaultHasSystemd() {
+    return existsSync('/run/systemd/system');
+}
+function defaultProbePactlInfo() {
+    try {
+        const out = execFileSync('pactl', ['info'], {
+            encoding: 'utf8',
+            timeout: PACTL_TIMEOUT_MS,
+            stdio: ['ignore', 'pipe', 'pipe'],
+        });
+        return out;
+    }
+    catch {
+        return null;
+    }
+}
+function defaultProbeChromeSandbox(electronBinary) {
+    const sandboxPath = resolveChromeSandboxPath(electronBinary);
+    try {
+        const stat = statSync(sandboxPath);
+        return { uid: stat.uid, mode: stat.mode };
+    }
+    catch {
+        return null;
+    }
+}
+function defaultProbeChromiumLibs(electronBinary) {
+    let stdout;
+    try {
+        stdout = execFileSync('ldd', [electronBinary], {
+            encoding: 'utf8',
+            timeout: LDD_TIMEOUT_MS,
+            stdio: ['ignore', 'pipe', 'pipe'],
+        });
+    }
+    catch (err) {
+        const stdoutFromError = err.stdout;
+        if (stdoutFromError == null)
+            return null;
+        stdout = typeof stdoutFromError === 'string' ? stdoutFromError : stdoutFromError.toString('utf8');
+    }
+    const missing = [];
+    for (const line of stdout.split('\n')) {
+        const match = line.match(/^\s*([\w./+-]+)\s*=>\s*not found/);
+        if (match?.[1])
+            missing.push(match[1]);
+    }
+    return missing;
+}
+export async function preflight(deps = {}) {
+    const platform = deps.platform ?? osPlatform();
+    const pathExists = deps.pathExists ?? existsSync;
+    const pathEnv = deps.pathEnv ?? deps.env?.PATH ?? process.env.PATH;
+    const resolveBinary = deps.resolveElectronBinary ?? resolveDefaultElectronBinary;
+    const appDir = (deps.resolveAppDir ?? resolveDefaultAppDir)();
+    const packageManager = detectPackageManager(pathEnv, pathExists);
+    const selfRepairAvailable = deps.selfRepairAvailable ?? true;
+    const checks = [
+        checkElectronBinary(resolveBinary, pathExists, selfRepairAvailable),
+        checkElectronHostDist(appDir, pathExists),
+    ];
+    if (platform === 'linux') {
+        checks.push(checkXvfb(pathEnv, pathExists, packageManager));
+        const probePactl = deps.probePactlInfo ?? defaultProbePactlInfo;
+        const hasSystemd = (deps.hasSystemd ?? defaultHasSystemd)();
+        checks.push(checkPipeWire(probePactl, packageManager, hasSystemd, pathEnv, pathExists));
+        const probeLibs = deps.probeChromiumLibs ?? defaultProbeChromiumLibs;
+        const electronBinary = resolveBinary();
+        checks.push(checkChromiumLibs(electronBinary, probeLibs, packageManager));
+        const probeSandbox = deps.probeChromeSandbox ?? defaultProbeChromeSandbox;
+        const sandboxMode = deps.sandboxMode ?? parseChromiumSandboxMode(deps.env ?? process.env).mode;
+        const inContainer = deps.probablyInContainer ?? probablyInContainer;
+        checks.push(checkChromeSandbox(electronBinary, probeSandbox, { sandboxMode, inContainer }));
+    }
+    const ok = checks.every((c) => c.ok || c.advisory === true);
+    return {
+        ok,
+        platform,
+        checks,
+        packageManager,
+    };
+}
+export function toBrowserPreflightPayload(result, opts) {
+    return {
+        ok: result.ok,
+        platform: result.platform,
+        packageManager: result.packageManager,
+        chromiumInstalling: opts.chromiumInstalling,
+        missing: result.checks
+            .filter((c) => !c.ok)
+            .map((c) => ({
+            id: c.id,
+            label: c.label,
+            reason: c.reason,
+            fixCommands: c.fixCommands,
+            advisory: c.advisory === true,
+        })),
+    };
+}
+function checkElectronBinary(resolveBinary, pathExists, selfRepairAvailable) {
+    const path = resolveBinary();
+    if (path && pathExists(path)) {
+        return {
+            id: 'electron',
+            label: 'Electron runtime',
+            ok: true,
+            detected: path,
+            reason: null,
+            fixCommands: [],
+        };
+    }
+    return {
+        id: 'electron',
+        label: 'Electron runtime',
+        ok: false,
+        detected: path,
+        reason: path
+            ? `Electron resolved to ${path} but its binary is missing on disk — the download was skipped at install time. Reinstall the browser runtime.`
+            : selfRepairAvailable
+                ?
+                    'The browser runtime (Electron) is not installed yet. Minionry installs it automatically when you open the Browser; if that cannot finish, run the command below — it installs Electron into the cli, so it works from any Space.'
+                : 'The browser runtime (Electron) is not installed and could not be installed automatically. Run the command below — it installs Electron into the cli itself, so the Browser works from any Space.',
+        fixCommands: selfRepairAvailable
+            ? ['minion install browser']
+            : [buildElectronRepairCommand(MINIONRY_ROOT)],
+    };
+}
+function checkElectronHostDist(appDir, pathExists) {
+    const mainPath = join(appDir, 'dist', 'main.js');
+    if (pathExists(mainPath)) {
+        return {
+            id: 'electron-host-dist',
+            label: 'Electron host build',
+            ok: true,
+            detected: mainPath,
+            reason: null,
+            fixCommands: [],
+        };
+    }
+    return {
+        id: 'electron-host-dist',
+        label: 'Electron host build',
+        ok: false,
+        detected: null,
+        reason: `electron-host build artifact not found at ${mainPath}. Run \`npm run build:electron-host\`.`,
+        fixCommands: ['npm run build:electron-host'],
+    };
+}
+function checkXvfb(pathEnv, pathExists, pm) {
+    const detected = lookupOnPath('Xvfb', pathEnv, pathExists);
+    if (detected) {
+        return {
+            id: 'xvfb',
+            label: 'Xvfb (virtual X display)',
+            ok: true,
+            detected,
+            reason: null,
+            fixCommands: [],
+        };
+    }
+    return {
+        id: 'xvfb',
+        label: 'Xvfb (virtual X display)',
+        ok: false,
+        detected: null,
+        reason: 'Xvfb not found on PATH. The Electron browser host needs a virtual X display on Linux — install Xvfb so headless Chromium can render.',
+        fixCommands: xvfbInstallCommands(pm),
+        systemFix: pm ? { packages: XVFB_PACKAGES[pm], steps: [] } : undefined,
+    };
+}
+function checkPipeWire(probePactlInfo, pm, hasSystemd, pathEnv, pathExists) {
+    const info = probePactlInfo();
+    if (info && /pipewire/i.test(info)) {
+        const serverNameLine = info.split('\n').find((l) => /server name/i.test(l));
+        return {
+            id: 'pipewire',
+            label: 'PipeWire audio server',
+            ok: true,
+            detected: serverNameLine?.trim() ?? 'pactl reports PipeWire',
+            reason: null,
+            fixCommands: [],
+        };
+    }
+    if (info && /pulseaudio/i.test(info)) {
+        return {
+            id: 'pipewire',
+            label: 'PipeWire audio server',
+            ok: false,
+            advisory: true,
+            detected: 'PulseAudio',
+            reason: 'Audio capture is using PulseAudio. Install PipeWire for monotonic timestamps (production-quality A/V sync). The browser host will still start.',
+            fixCommands: pipewireInstallCommands(pm, hasSystemd),
+        };
+    }
+    const pipewire = lookupOnPath('pipewire', pathEnv, pathExists);
+    const pactl = lookupOnPath('pactl', pathEnv, pathExists);
+    if (pipewire && !pactl) {
+        const fix = pm ? { packages: [PACTL_PACKAGE[pm]], steps: [], skipNote: AUDIO_SKIP_NOTE } : undefined;
+        return {
+            id: 'pipewire',
+            label: 'PipeWire audio server',
+            ok: false,
+            advisory: true,
+            detected: pipewire,
+            reason: 'PipeWire is installed, but `pactl` is not — the browser host needs it to route page audio. Install it to enable audio capture.',
+            fixCommands: fix
+                ? fixBlock(fix, pm, true)
+                : ['# Install `pactl` for your distribution (usually in pulseaudio-utils).'],
+            systemFix: fix,
+        };
+    }
+    if (pipewire) {
+        if (!hasSystemd) {
+            return {
+                id: 'pipewire',
+                label: 'PipeWire audio server',
+                ok: false,
+                advisory: true,
+                detected: pipewire,
+                reason: 'PipeWire is installed but not running, and nothing here can start it — this machine has no systemd (typical in a container). Audio capture stays off; the browser works without it.',
+                fixCommands: [
+                    '# Nothing to install: PipeWire is installed, but this machine has no',
+                    '# systemd to start it (typical in a container). Audio capture stays off.',
+                ],
+            };
+        }
+        const fix = { packages: [], steps: userServiceEnableSteps(hasSystemd), skipNote: AUDIO_SERVICE_SKIP_NOTE };
+        return {
+            id: 'pipewire',
+            label: 'PipeWire audio server',
+            ok: false,
+            advisory: true,
+            detected: pipewire,
+            reason: 'PipeWire is installed but not running for this user. Enable its user services to turn on audio capture.',
+            fixCommands: fixBlock(fix, pm, true),
+            systemFix: fix,
+        };
+    }
+    return {
+        id: 'pipewire',
+        label: 'PipeWire audio server',
+        ok: false,
+        advisory: true,
+        detected: null,
+        reason: 'No sound server answered `pactl info`. Audio capture will be disabled. Install PipeWire (recommended) to enable it.',
+        fixCommands: pipewireInstallCommands(pm, hasSystemd),
+        systemFix: pm ? pipewireFix(pm, hasSystemd) : undefined,
+    };
+}
+function checkChromiumLibs(electronBinary, probe, pm) {
+    if (!electronBinary) {
+        return {
+            id: 'chromium-libs',
+            label: 'Chromium runtime libraries',
+            ok: true,
+            detected: 'not checked — Electron runtime missing',
+            reason: null,
+            fixCommands: [],
+        };
+    }
+    const missing = probe(electronBinary);
+    if (missing === null) {
+        return {
+            id: 'chromium-libs',
+            label: 'Chromium runtime libraries',
+            ok: true,
+            detected: 'ldd unavailable — skipped',
+            reason: null,
+            fixCommands: [],
+        };
+    }
+    if (missing.length === 0) {
+        return {
+            id: 'chromium-libs',
+            label: 'Chromium runtime libraries',
+            ok: true,
+            detected: 'all libraries present',
+            reason: null,
+            fixCommands: [],
+        };
+    }
+    return {
+        id: 'chromium-libs',
+        label: 'Chromium runtime libraries',
+        ok: false,
+        detected: missing.join(', '),
+        reason: `Electron's Chromium can't start — the dynamic linker reports these libraries as not found: ${missing.join(', ')}. ` +
+            'Install the system-wide Chromium runtime dependencies.',
+        fixCommands: chromiumLibsInstallCommands(pm),
+        systemFix: pm ? chromiumLibsFix(pm) : undefined,
+    };
+}
+function checkChromeSandbox(electronBinary, probe, policy) {
+    if (policy.sandboxMode === 'off') {
+        return {
+            id: 'chrome-sandbox',
+            label: 'Chromium sandbox helper',
+            ok: true,
+            detected: 'not needed — Chromium sandbox off (MINIONRY_CHROMIUM_SANDBOX=off)',
+            reason: null,
+            fixCommands: [],
+        };
+    }
+    if (!electronBinary) {
+        return {
+            id: 'chrome-sandbox',
+            label: 'Chromium sandbox helper',
+            ok: true,
+            detected: 'not checked — Electron runtime missing',
+            reason: null,
+            fixCommands: [],
+        };
+    }
+    const stat = probe(electronBinary);
+    if (stat === null) {
+        return {
+            id: 'chrome-sandbox',
+            label: 'Chromium sandbox helper',
+            ok: true,
+            detected: 'chrome-sandbox not present — skipped (older Electron build)',
+            reason: null,
+            fixCommands: [],
+        };
+    }
+    if (isSandboxConfigured(stat.uid, stat.mode)) {
+        return {
+            id: 'chrome-sandbox',
+            label: 'Chromium sandbox helper',
+            ok: true,
+            detected: 'root-owned, mode 4755',
+            reason: null,
+            fixCommands: [],
+        };
+    }
+    const sandboxPath = resolveChromeSandboxPath(electronBinary);
+    const actualMode = (stat.mode & 0o7777).toString(8).padStart(4, '0');
+    const misconfigured = `${sandboxPath} must be owned by root with mode 4755 (currently uid=${stat.uid}, mode=${actualMode}). `;
+    if (policy.sandboxMode === 'auto' && policy.inContainer()) {
+        const fix = {
+            packages: [],
+            steps: buildFixSteps(sandboxPath),
+            skipNote: 'Chromium sandbox helper not fixed. The browser runs without its sandbox in this container.',
+        };
+        return {
+            id: 'chrome-sandbox',
+            label: 'Chromium sandbox helper',
+            ok: false,
+            advisory: true,
+            detected: `uid=${stat.uid} mode=${actualMode}`,
+            reason: `${misconfigured}Not blocking inside a container: when Chromium cannot start its sandbox here, the browser host ` +
+                'relaunches without it and the container is the isolation boundary (MINIONRY_CHROMIUM_SANDBOX=auto). ' +
+                'Fix the helper to keep the sandbox on when the container is started with a seccomp profile that allows user namespaces.',
+            fixCommands: fixBlock(fix, null, true),
+            systemFix: fix,
+        };
+    }
+    const fix = { packages: [], steps: buildFixSteps(sandboxPath) };
+    return {
+        id: 'chrome-sandbox',
+        label: 'Chromium sandbox helper',
+        ok: false,
+        detected: `uid=${stat.uid} mode=${actualMode}`,
+        reason: `${misconfigured}Chromium aborts at launch otherwise — this is npm's standard post-install gap for the Electron tarball. ` +
+            'Re-run this after each Minionry update: reinstalling the package re-extracts Electron and strips the setuid bit again.',
+        fixCommands: fixBlock(fix, null),
+        systemFix: fix,
+    };
+}
+export class BrowserPreflightError extends Error {
+    code = 'BROWSER_PREFLIGHT_FAILED';
+    missing;
+    packageManager;
+    platform;
+    constructor(result) {
+        const missing = result.checks.filter((c) => !c.ok && !c.advisory);
+        const summary = missing.map((c) => c.label).join(', ');
+        super(`Browser preflight failed — missing: ${summary || 'unknown'}.`);
+        this.name = 'BrowserPreflightError';
+        this.missing = missing;
+        this.packageManager = result.packageManager;
+        this.platform = result.platform;
+    }
+    toJSON() {
+        return {
+            code: this.code,
+            message: this.message,
+            platform: this.platform,
+            packageManager: this.packageManager,
+            missing: this.missing,
+        };
+    }
+}
+export function lookupOnPath(name, pathEnv, pathExists = existsSync) {
+    if (!pathEnv)
+        return null;
+    for (const dir of pathEnv.split(delimiter)) {
+        if (!dir)
+            continue;
+        const candidate = join(dir, name);
+        if (pathExists(candidate))
+            return candidate;
+    }
+    return null;
+}
+export function detectPackageManager(pathEnv, pathExists = existsSync) {
+    if (lookupOnPath('apt-get', pathEnv, pathExists))
+        return 'apt';
+    if (lookupOnPath('dnf', pathEnv, pathExists))
+        return 'dnf';
+    if (lookupOnPath('pacman', pathEnv, pathExists))
+        return 'pacman';
+    if (lookupOnPath('apk', pathEnv, pathExists))
+        return 'apk';
+    return null;
+}
+const XVFB_PACKAGES = {
+    apt: ['xvfb', 'xauth'],
+    dnf: ['xorg-x11-server-Xvfb', 'xorg-x11-xauth'],
+    pacman: ['xorg-server-xvfb', 'xorg-xauth'],
+    apk: ['xvfb', 'xauth'],
+};
+export function xvfbInstallCommands(pm) {
+    if (pm === null) {
+        return [
+            '# No supported package manager detected (apt/dnf/pacman/apk).',
+            '# Install Xvfb manually for your distribution — the canonical',
+            '# binary name is `Xvfb` (case-sensitive) on PATH.',
+        ];
+    }
+    return fixBlock({ packages: XVFB_PACKAGES[pm], steps: [] }, pm);
+}
+const PIPEWIRE_PACKAGES = {
+    apt: ['pipewire', 'pipewire-pulse', 'wireplumber', 'pulseaudio-utils'],
+    dnf: ['pipewire', 'pipewire-pulseaudio', 'wireplumber', 'pulseaudio-utils'],
+    pacman: ['pipewire', 'pipewire-pulse', 'wireplumber', 'libpulse'],
+    apk: ['pipewire', 'pipewire-pulse', 'wireplumber', 'pulseaudio-utils'],
+};
+const PACTL_PACKAGE = {
+    apt: 'pulseaudio-utils',
+    dnf: 'pulseaudio-utils',
+    pacman: 'libpulse',
+    apk: 'pulseaudio-utils',
+};
+const AUDIO_SKIP_NOTE = 'Audio setup did not finish. It is optional: the browser works without it.';
+const AUDIO_SERVICE_SKIP_NOTE = 'Audio did not start yet (optional: the browser works without it). Log in once or reboot, then run this again.';
+function pipewireFix(pm, hasSystemd) {
+    const steps = pm === 'apk' ? [] : userServiceEnableSteps(hasSystemd);
+    return {
+        packages: PIPEWIRE_PACKAGES[pm],
+        steps,
+        skipNote: steps.length > 0 ? AUDIO_SERVICE_SKIP_NOTE : AUDIO_SKIP_NOTE,
+    };
+}
+export function pipewireInstallCommands(pm, hasSystemd = defaultHasSystemd()) {
+    if (pm === null) {
+        return [
+            '# No supported package manager detected (apt/dnf/pacman/apk).',
+            '# Install pipewire + pipewire-pulse (or pipewire-pulseaudio on Fedora)',
+            '# + wireplumber + pactl (pulseaudio-utils) for your distribution,',
+            '# then enable the user services.',
+        ];
+    }
+    return fixBlock(pipewireFix(pm, hasSystemd), pm, true);
+}
+function userServiceEnableSteps(hasSystemd) {
+    if (!hasSystemd)
+        return [];
+    return [
+        'sudo loginctl enable-linger "$USER"',
+        'XDG_RUNTIME_DIR="/run/user/$(id -u)" systemctl --user --now enable pipewire pipewire-pulse wireplumber',
+    ];
+}
+export function chromiumInstallCommands(_platform) {
+    return ['minion install browser'];
+}
+const CHROMIUM_LIB_PACKAGES = {
+    apt: [
+        'libnss3', 'libnspr4', 'libdbus-1-3', 'libatk1.0-0', 'libatk-bridge2.0-0',
+        'libcups2', 'libdrm2', 'libxkbcommon0', 'libxcomposite1', 'libxdamage1',
+        'libxfixes3', 'libxrandr2', 'libgbm1', 'libpango-1.0-0', 'libcairo2',
+        'libxshmfence1', 'libxtst6', 'libatspi2.0-0', 'libnotify4', 'libsecret-1-0',
+    ],
+    dnf: [
+        'nss', 'nspr', 'at-spi2-atk', 'cups-libs', 'libdrm', 'libXcomposite', 'libXdamage',
+        'libXfixes', 'libXrandr', 'libXScrnSaver', 'libXtst', 'libxshmfence',
+        'mesa-libgbm', 'pango', 'cairo', 'alsa-lib', 'libnotify', 'libsecret', 'gtk3',
+    ],
+    pacman: [
+        'nss', 'nspr', 'at-spi2-atk', 'libcups', 'libdrm', 'libxcomposite', 'libxdamage',
+        'libxfixes', 'libxrandr', 'libxss', 'libxtst', 'libxshmfence',
+        'mesa', 'pango', 'cairo', 'alsa-lib', 'libnotify', 'libsecret', 'gtk3',
+    ],
+    apk: [
+        'nss', 'nspr', 'dbus-libs', 'at-spi2-atk', 'cups-libs', 'libdrm', 'libxkbcommon',
+        'libxcomposite', 'libxdamage', 'libxfixes', 'libxrandr', 'libxscrnsaver', 'libxtst',
+        'mesa-gbm', 'pango', 'cairo', 'alsa-lib', 'libnotify', 'libsecret', 'gtk+3.0',
+    ],
+};
+const APT_TIME64_STEP = '{ sudo apt-get install -y libasound2t64 libgtk-3-0t64 || \\\n    sudo apt-get install -y libasound2 libgtk-3-0; }';
+function chromiumLibsFix(pm) {
+    return { packages: CHROMIUM_LIB_PACKAGES[pm], steps: pm === 'apt' ? [APT_TIME64_STEP] : [] };
+}
+export function chromiumLibsInstallCommands(pm) {
+    if (pm === null) {
+        return [
+            '# No supported package manager detected (apt/dnf/pacman/apk).',
+            '# Install the Chromium runtime libraries for your distribution.',
+            '# Canonical Debian/Ubuntu names: libnss3, libnspr4, libdbus-1-3,',
+            '# libatk1.0, libatk-bridge2.0, libcups2, libdrm2, libxkbcommon0,',
+            '# libxcomposite1, libxdamage1, libxfixes3, libxrandr2, libgbm1,',
+            '# libpango-1.0, libcairo2, libasound2, libgtk-3-0, libxss1,',
+            '# libxtst6, libatspi2.0-0, libnotify4, libsecret-1-0, libxshmfence1.',
+        ];
+    }
+    return fixBlock(chromiumLibsFix(pm), pm);
+}