@ciphore/radiocli 0.2.3 → 0.2.5

package/dist/setup.js

@@ -1,50 +1,102 @@
+import { componentLabel, detectPackageManager, packageCommandInvocation, packageInstallCommand, packageInstallPrerequisites, packageManagerElevation, packageManagerNeedsRoot, packageManagerNotes, packageManagerProgram, packageManagers, platformLabel } from './platform/packages.js';
 import { spawn } from 'node:child_process';
-import { existsSync, readFileSync, realpathSync } from 'node:fs';
+import { realpathSync } from 'node:fs';
 import { createInterface } from 'node:readline/promises';
-import { clearCommandCache, commandExists } from './player/command.js';
+import { clearCommandCache, commandExists, resolveCommand } from './platform/executables.js';
 import { detectPlaybackBackends, playbackBackendStatusLines } from './player/backend-install.js';
 import { configureMcpIntegrations } from './agent/mcp-install.js';
-import { JsonLibraryStore } from './storage/store.js';
+import { defaultLibraryPath, JsonLibraryStore } from './storage/store.js';
 import { defaultAgentControlSettings } from './types.js';
+import { resolveTerminalCapabilities } from './platform/terminal.js';
+import { isAirPlayPlatformSupported } from './player/airplay-policy.js';
+import { probeAirPlayReadiness } from './player/airplay-readiness.js';
+import { airPlaySetupVerification, hasSystemdSystemManager, linuxAirPlaySetupPlan } from './player/airplay-setup.js';
+import { readSettingsWithoutMigration } from './storage/read-settings.js';
+import { identifyPlatform, readLinuxOsRelease } from './platform/runtime.js';
+import { verifyLocalPlayback } from './setup-playback.js';
 const components = ['mpv', 'ffmpeg', 'vlc'];
-const packageManagers = ['brew', 'winget', 'scoop', 'choco', 'apt', 'dnf', 'pacman', 'apk', 'zypper'];
 export async function runSetup(options = {}) {
     const platform = options.platform ?? process.platform;
     const osRelease = options.osRelease ?? readLinuxOsRelease(platform);
+    const env = options.env ?? process.env;
+    const host = identifyPlatform({ platform, osRelease, env });
     const input = options.input ?? process.stdin;
     const output = options.output ?? process.stdout;
     const hasCommand = options.hasCommand ?? commandExists;
     const parsed = parseSetupArgs(options.args ?? []);
+    const linuxAirPlayEligible = platform === 'linux' && isAirPlayPlatformSupported(platform, env, host.release);
+    if (parsed.airplay !== null && !linuxAirPlayEligible)
+        throw new Error('--airplay and --no-airplay configure experimental native Linux AirPlay only. macOS keeps its existing AirPlay setup; this environment has no Linux opt-in.');
+    const prompt = options.prompt ?? ((question, defaultValue) => promptYesNo(input, output, question, defaultValue));
+    const libraryPath = () => options.libraryPath ?? defaultLibraryPath({ platform, env, home: env.HOME ?? env.USERPROFILE });
+    const probe = options.probeAirPlay ?? ((loadSender) => probeAirPlayReadiness({ platform, env, release: host.release, hasCommand, ...(loadSender ? {} : { sender: async () => ({ loaded: false, message: 'Not probed before approval.' }) }) }));
+    if (parsed.packageManager)
+        validateNativePackageManager(parsed.packageManager, host);
     const installed = detectInstalledComponents(hasCommand);
-    const packageManager = parsed.packageManager ?? detectPackageManager(platform, osRelease, hasCommand);
+    const packageManager = parsed.packageManager ?? detectPackageManager(platform, osRelease, hasCommand, env);
     writeHeader(output);
-    output.write(`System  ${platformLabel(platform, osRelease)} · Node ${process.version}\n`);
+    output.write(`System  ${platformLabel(platform, osRelease, env)} ${separator(output)} Node ${process.version}\n`);
     output.write(`Manager ${packageManager ?? 'not detected'}\n\n`);
     let selected = parsed.only ?? defaultComponents(platform, parsed.all);
     if (!parsed.yes && !parsed.only && isInteractive(input, output)) {
-        selected = await promptForComponents({ platform, installed, input, output });
+        selected = await promptForComponents({ platform, installed, output, prompt });
+    }
+    let airplay = parsed.airplay;
+    if (linuxAirPlayEligible && airplay === null && !parsed.yes && !parsed.only && isInteractive(input, output)) {
+        const enabled = readSettingsWithoutMigration(libraryPath())?.linuxAirPlayEnabled === true;
+        const choice = await prompt('  AirPlay — experimental (FFmpeg, shared Avahi network discovery)', enabled);
+        // Declining the default on a new install leaves the library untouched.
+        if (choice || enabled)
+            airplay = choice;
     }
     let mcp = parsed.mcp;
     if (mcp === null && !parsed.yes && isInteractive(input, output)) {
-        mcp = await promptYesNo(input, output, '  Agent control via MCP (detected coding agents)', true);
+        mcp = await prompt('  Agent control via MCP (detected coding agents)', true);
     }
     let agentUi = parsed.agentUi;
     if (mcp === true && agentUi === null && !parsed.yes && isInteractive(input, output)) {
         const note = platform === 'darwin'
             ? ' (macOS will ask the agent app to control Terminal on first use)'
             : ' (opens a separate terminal window)';
-        agentUi = await promptYesNo(input, output, `  Open the RadioCLI TUI for agent playback${note}`, true);
-    }
-    const plan = createSetupPlan({ platform, osRelease, packageManager, installed, selected });
+        agentUi = await prompt(`  Open the RadioCLI TUI for agent playback${note}`, true);
+    }
+    const isRoot = (options.getUid ?? process.getuid)?.() === 0;
+    const elevation = packageManagerElevation(hasCommand, isRoot);
+    const plan = createSetupPlan({ platform, osRelease, env, packageManager, installed, selected, elevation });
+    const airPlayPlan = airplay === true ? linuxAirPlaySetupPlan({ manager: packageManager, elevation, hasCommand,
+        systemd: (options.isSystemd ?? hasSystemdSystemManager)(),
+        serviceReady: parsed.dryRun ? false : (await probe(false).catch(() => null))?.discoveryService === 'ready', existingCommands: plan.commands }) : null;
+    if (airPlayPlan)
+        plan.commands.push(...airPlayPlan.commands);
     printPlan(plan, output);
+    if (airplay !== null)
+        output.write(`  Linux AirPlay: ${airplay ? 'enable for this library after accepted setup; verify sender and discovery' : 'disable for this library; keep installed packages and shared services'}\n`);
+    for (const note of airPlayPlan?.notes ?? [])
+        output.write(`  Note: ${note}\n`);
+    if (packageManager && packageManagerNeedsRoot(packageManager) && !isRoot && !elevation) {
+        output.write('  Note: Run package commands as root; sudo/doas unavailable.\n');
+    }
+    for (const note of packageManagerNotes(packageManager, host))
+        output.write(`  Note: ${note}\n`);
+    const verify = async () => {
+        let linuxAirPlayEnabled = airplay === true;
+        if (platform === 'linux' && airplay === null) {
+            try {
+                linuxAirPlayEnabled = readSettingsWithoutMigration(libraryPath())?.linuxAirPlayEnabled === true;
+            }
+            catch { /* Unreadable consent stays disabled. */ }
+        }
+        await printVerification(output, { platform, osRelease, env, release: host.release, hasCommand, getUid: options.getUid, linuxAirPlayEnabled, verifyPlayback: options.verifyPlayback });
+    };
     const missing = plan.selected.filter(component => !plan.installed[component]);
-    if (missing.length === 0) {
+    if (missing.length === 0 && airplay === null) {
         output.write(plan.selected.length === 0 ? '\nNo components selected.\n' : '\nEverything selected is already installed.\n');
         await finishMcpSetup(mcp, agentUi, parsed.dryRun, output);
-        printVerification(output);
+        if (!parsed.dryRun)
+            await verify();
         return;
     }
-    if (!plan.packageManager) {
+    if (!plan.packageManager && missing.length > 0) {
         if (parsed.dryRun) {
             output.write('\nDry run complete. Install the missing components manually; no system packages were changed.\n');
             await finishMcpSetup(mcp, agentUi, true, output);
@@ -57,11 +109,20 @@ export async function runSetup(options = {}) {
         await finishMcpSetup(mcp, agentUi, true, output);
         return;
     }
-    if (parsed.packageManager && !hasCommand(parsed.packageManager)) {
-        throw new Error(`Requested package manager is not available: ${parsed.packageManager}.`);
+    const manual = missing.filter(component => !plan.commands.some(command => command.component === component));
+    if (manual.length)
+        throw new Error(`No verified automatic installation command for ${manual.join(', ')} with ${plan.packageManager}. Install these components manually or select --only=mpv.`);
+    if (plan.packageManager === 'termux-pkg' && isRoot)
+        throw new Error('Run setup as the normal Termux app user. Termux pkg refuses root execution.');
+    if ((plan.packageManager && packageManagerNeedsRoot(plan.packageManager) || airPlayPlan?.commands.length) && plan.commands.length > 0 && !isRoot && !elevation) {
+        throw new Error('System package installation requires root, sudo, or doas. Review the dry-run plan and install prerequisites with your administrator.');
+    }
+    if (plan.commands.length > 0 && parsed.packageManager && !hasCommand(packageManagerProgram(parsed.packageManager))) {
+        const program = packageManagerProgram(parsed.packageManager);
+        throw new Error(`Requested package manager is not available: ${parsed.packageManager}${program !== parsed.packageManager ? ` (${program})` : ''}.`);
     }
     if (!parsed.yes && isInteractive(input, output)) {
-        const confirmed = await promptYesNo(input, output, '\nInstall these components?', true);
+        const confirmed = await prompt(airplay === null ? '\nInstall these components?' : '\nApply this setup plan and Linux AirPlay preference?', true);
         if (!confirmed) {
             output.write('Setup cancelled. No system packages were changed.\n');
             return;
@@ -70,62 +131,59 @@ export async function runSetup(options = {}) {
     else if (!parsed.yes) {
         throw new Error('Setup needs an interactive terminal. Use --yes to approve the displayed commands or --dry-run to inspect them.');
     }
-    if (plan.commands.some(command => command.program === 'sudo')) {
+    if (!options.runCommand && plan.commands.some(command => command.program === 'sudo')) {
         output.write('\nRadioCLI needs administrator approval for the system package manager.\n');
-        await runVisibleCommand('sudo', ['-v']);
+        await runVisibleCommand(resolveCommand('sudo') ?? 'sudo', ['-v']);
     }
-    const execute = options.runCommand ?? runInstallCommand;
-    output.write('\nInstalling\n');
+    const execute = options.runCommand ?? ((command, destination) => runInstallCommand(command, destination, platform));
+    if (plan.commands.length)
+        output.write('\nInstalling\n');
     for (const command of plan.commands) {
         await execute(command, output);
     }
     clearCommandCache();
+    if (airplay !== null) {
+        if (options.saveLinuxAirPlayEnabled)
+            options.saveLinuxAirPlayEnabled(airplay);
+        else
+            new JsonLibraryStore(libraryPath()).updateSettings({ linuxAirPlayEnabled: airplay });
+        output.write(`\nLinux AirPlay ${airplay ? 'enabled' : 'disabled'} for this library. Restart active RadioCLI sessions to apply this preference.\n`);
+        if (airplay) {
+            const readiness = await probe(true).catch(() => ({ eligible: true, discoveryExecutable: false, discoveryService: 'unverified', senderLoaded: false, ffmpeg: false, ready: false, message: 'Readiness could not be verified. Run radiocli doctor.' }));
+            for (const line of airPlaySetupVerification(readiness))
+                output.write(`  ${line}\n`);
+        }
+    }
     output.write('\nSetup complete.\n');
     await finishMcpSetup(mcp, agentUi, false, output);
-    printVerification(output);
+    await verify();
 }
-export function createSetupPlan({ platform, osRelease = '', packageManager, installed, selected }) {
+export function createSetupPlan({ platform, osRelease = '', env = process.env, packageManager, installed, selected, elevation = 'sudo' }) {
+    if (packageManager)
+        validateNativePackageManager(packageManager, identifyPlatform({ platform, osRelease, env }));
     const uniqueSelected = components.filter(component => selected.includes(component));
     const missing = uniqueSelected.filter(component => !installed[component]);
-    const commands = packageManager ? missing.map(component => packageInstallCommand(packageManager, component)) : [];
-    if (packageManager === 'scoop' && missing.some(component => component === 'mpv' || component === 'vlc')) {
-        commands.unshift({
-            component: null,
-            label: 'Scoop extras bucket',
-            program: 'scoop',
-            args: ['bucket', 'add', 'extras'],
-            display: 'scoop bucket add extras'
-        });
-    }
+    const commands = packageManager ? missing.map(component => packageInstallCommand(packageManager, component, { elevation })).filter((command) => command !== null) : [];
+    if (packageManager)
+        commands.unshift(...packageInstallPrerequisites(packageManager, missing));
     return {
         platform,
-        platformLabel: platformLabel(platform, osRelease),
+        platformLabel: platformLabel(platform, osRelease, env),
         packageManager,
         installed,
         selected: uniqueSelected,
         commands
     };
 }
-export function detectPackageManager(platform, osRelease, hasCommand = commandExists) {
-    if (platform === 'darwin')
-        return hasCommand('brew') ? 'brew' : null;
-    if (platform === 'win32')
-        return firstAvailable(['winget', 'scoop', 'choco'], hasCommand);
-    if (platform !== 'linux')
-        return null;
-    const ids = linuxReleaseIds(osRelease);
-    const preferred = hasAny(ids, ['debian', 'ubuntu', 'linuxmint', 'pop'])
-        ? ['apt']
-        : hasAny(ids, ['fedora', 'rhel', 'centos'])
-            ? ['dnf']
-            : hasAny(ids, ['arch', 'manjaro'])
-                ? ['pacman']
-                : hasAny(ids, ['alpine'])
-                    ? ['apk']
-                    : hasAny(ids, ['opensuse', 'suse'])
-                        ? ['zypper']
-                        : ['apt', 'dnf', 'pacman', 'apk', 'zypper'];
-    return firstAvailable(preferred, hasCommand);
+function validateNativePackageManager(manager, host) {
+    const required = host.id === 'termux' ? 'termux-pkg' : host.id === 'haiku' ? 'pkgman' : host.id === 'sunos' ? 'pkgin' : null;
+    if ((required && manager !== required)
+        || (manager === 'termux-pkg' && host.id !== 'termux')
+        || (manager === 'pkgman' && host.id !== 'haiku')
+        || (manager === 'pkg' && host.id !== 'freebsd')
+        || ['aix', 'android', 'unknown'].includes(host.id)) {
+        throw new Error(`No verified ${manager} playback package recipe for ${host.id}.${required ? ` Use --package-manager=${required}.` : ' Install a native player manually and run radiocli doctor.'}`);
+    }
 }
 export function parseSetupArgs(args) {
     let all = false;
@@ -135,6 +193,7 @@ export function parseSetupArgs(args) {
     let packageManager = null;
     let mcp = null;
     let agentUi = null;
+    let airplay = null;
     for (let index = 0; index < args.length; index += 1) {
         const arg = args[index];
         if (arg === '--all')
@@ -143,6 +202,12 @@ export function parseSetupArgs(args) {
             dryRun = true;
         else if (arg === '--yes' || arg === '-y')
             yes = true;
+        else if (arg === '--airplay' || arg === '--no-airplay') {
+            const enabled = arg === '--airplay';
+            if (airplay !== null && airplay !== enabled)
+                throw new Error('Use either --airplay or --no-airplay, not both.');
+            airplay = enabled;
+        }
         else if (arg === '--mcp') {
             if (mcp === false)
                 throw new Error('Use either --mcp or --no-mcp, not both.');
@@ -178,7 +243,7 @@ export function parseSetupArgs(args) {
         throw new Error('Use either --all or --only, not both.');
     if (agentUi !== null && mcp !== true)
         throw new Error('--agent-ui and --headless-agent require --mcp.');
-    return { all, dryRun, yes, only, packageManager, mcp, agentUi };
+    return { all, dryRun, yes, only, packageManager, mcp, agentUi, airplay };
 }
 async function finishMcpSetup(enabled, agentUi, dryRun, output) {
     if (enabled === null)
@@ -220,51 +285,6 @@ function parsePackageManager(value) {
     }
     return value;
 }
-function packageInstallCommand(manager, component) {
-    const packages = {
-        brew: { mpv: 'mpv', ffmpeg: 'ffmpeg', vlc: 'vlc' },
-        winget: { mpv: 'shinchiro.mpv', ffmpeg: 'Gyan.FFmpeg', vlc: 'VideoLAN.VLC' },
-        scoop: { mpv: 'mpv', ffmpeg: 'ffmpeg', vlc: 'vlc' },
-        choco: { mpv: 'mpv', ffmpeg: 'ffmpeg', vlc: 'vlc' },
-        apt: { mpv: 'mpv', ffmpeg: 'ffmpeg', vlc: 'vlc' },
-        dnf: { mpv: 'mpv', ffmpeg: 'ffmpeg', vlc: 'vlc' },
-        pacman: { mpv: 'mpv', ffmpeg: 'ffmpeg', vlc: 'vlc' },
-        apk: { mpv: 'mpv', ffmpeg: 'ffmpeg', vlc: 'vlc' },
-        zypper: { mpv: 'mpv', ffmpeg: 'ffmpeg', vlc: 'vlc' }
-    };
-    const packageName = packages[manager][component];
-    let program = manager;
-    let args;
-    if (manager === 'brew')
-        args = ['install', component === 'vlc' ? '--cask' : packageName, ...(component === 'vlc' ? [packageName] : [])];
-    else if (manager === 'winget')
-        args = ['install', '--id', packageName, '-e', '--accept-package-agreements', '--accept-source-agreements'];
-    else if (manager === 'scoop')
-        args = ['install', packageName];
-    else if (manager === 'choco')
-        args = ['install', packageName, '-y'];
-    else if (manager === 'apt') {
-        program = 'sudo';
-        args = ['apt-get', 'install', '-y', packageName];
-    }
-    else if (manager === 'dnf') {
-        program = 'sudo';
-        args = ['dnf', 'install', '-y', packageName];
-    }
-    else if (manager === 'pacman') {
-        program = 'sudo';
-        args = ['pacman', '-S', '--needed', '--noconfirm', packageName];
-    }
-    else if (manager === 'apk') {
-        program = 'sudo';
-        args = ['apk', 'add', packageName];
-    }
-    else {
-        program = 'sudo';
-        args = ['zypper', '--non-interactive', 'install', packageName];
-    }
-    return { component, label: componentLabel(component), program, args, display: [program, ...args].join(' ') };
-}
 function defaultComponents(platform, all) {
     if (all)
         return [...components];
@@ -277,14 +297,14 @@ function detectInstalledComponents(hasCommand) {
         vlc: hasCommand('vlc') || hasCommand('cvlc')
     };
 }
-async function promptForComponents({ platform, installed, input, output }) {
+async function promptForComponents({ platform, installed, output, prompt }) {
     output.write('Choose components (installed items will be skipped):\n');
     const selected = [];
-    if (await promptYesNo(input, output, `  mpv      Full playback controls${installed.mpv ? ' · installed' : ''}`, true))
+    if (await prompt(`  mpv      Full playback controls${installed.mpv ? ` ${separator(output)} installed` : ''}`, true))
         selected.push('mpv');
-    if (await promptYesNo(input, output, `  FFmpeg   ${platform === 'darwin' ? 'AirPlay + ' : ''}ffplay fallback${installed.ffmpeg ? ' · installed' : ''}`, platform === 'darwin'))
+    if (await prompt(`  FFmpeg   ${platform === 'darwin' ? 'AirPlay + ' : ''}ffplay fallback${installed.ffmpeg ? ` ${separator(output)} installed` : ''}`, platform === 'darwin'))
         selected.push('ffmpeg');
-    if (await promptYesNo(input, output, `  VLC      Additional playback fallback${installed.vlc ? ' · installed' : ''}`, false))
+    if (await prompt(`  VLC      Additional playback fallback${installed.vlc ? ` ${separator(output)} installed` : ''}`, false))
         selected.push('vlc');
     return selected;
 }
@@ -302,19 +322,23 @@ async function promptYesNo(input, output, question, defaultValue) {
 }
 function printPlan(plan, output) {
     output.write('\nInstallation plan\n');
+    for (const command of plan.commands.filter(command => command.component === null)) {
+        output.write(`  ${pendingMark(output)} ${command.label} ${separator(output)} ${command.display}\n`);
+    }
     for (const component of plan.selected) {
         if (plan.installed[component])
             output.write(`  ${successMark(output)} ${componentLabel(component)} already installed\n`);
         else {
             const command = plan.commands.find(candidate => candidate.component === component);
-            output.write(`  ${pendingMark(output)} ${componentLabel(component)}${command ? ` · ${command.display}` : ' · manual installation required'}\n`);
+            output.write(`  ${pendingMark(output)} ${componentLabel(component)} ${separator(output)} ${command ? command.display : 'manual installation required'}\n`);
         }
     }
     if (plan.selected.length === 0)
         output.write('  No components selected\n');
 }
-async function runInstallCommand(command, output) {
-    const interactive = Boolean(output.isTTY);
+async function runInstallCommand(command, output, platform) {
+    const terminal = setupTerminal(output);
+    const interactive = terminal.interactive && !terminal.reduceMotion;
     const startedAt = Date.now();
     let timer;
     let frame = 0;
@@ -330,7 +354,8 @@ async function runInstallCommand(command, output) {
     }
     try {
         await new Promise((resolve, reject) => {
-            const child = spawn(command.program, command.args, { stdio: ['inherit', 'pipe', 'pipe'] });
+            const invocation = packageCommandInvocation(command, platform, resolveCommand);
+            const child = spawn(invocation.program, invocation.args, { shell: false, stdio: ['inherit', 'pipe', 'pipe'] });
             child.stdout?.on('data', chunk => { stdout = tail(`${stdout}${String(chunk)}`); });
             child.stderr?.on('data', chunk => { stderr = tail(`${stderr}${String(chunk)}`); });
             child.once('error', reject);
@@ -358,55 +383,57 @@ function progressFrame(label, frame, elapsedMs, output) {
     const cycle = travel * 2;
     const offset = frame % cycle;
     const start = offset <= travel ? offset : cycle - offset;
-    const bar = Array.from({ length: width }, (_, index) => index >= start && index < start + segment ? '█' : '░').join('');
-    return `  ${accent(output, '◒')} ${accent(output, `[${bar}]`)} Installing ${label} ${formatElapsed(elapsedMs)}`;
+    const unicode = setupTerminal(output).unicode;
+    const bar = Array.from({ length: width }, (_, index) => index >= start && index < start + segment ? (unicode ? '█' : '#') : (unicode ? '░' : '.')).join('');
+    return `  ${accent(output, unicode ? '◒' : '*')} ${accent(output, `[${bar}]`)} Installing ${label} ${formatElapsed(elapsedMs)}`;
 }
-function printVerification(output) {
+async function printVerification(output, { platform, osRelease, env, release, hasCommand, getUid, linuxAirPlayEnabled, verifyPlayback = verifyLocalPlayback }) {
     clearCommandCache();
-    const backends = detectPlaybackBackends();
+    const backends = detectPlaybackBackends({ platform, env, release, hasCommand, settings: { linuxAirPlayEnabled } });
     output.write('\nVerification\n');
     output.write(`  Playback backends: ${backends.join(', ') || 'none'}\n`);
-    for (const line of playbackBackendStatusLines(backends).slice(0, 3))
+    for (const line of playbackBackendStatusLines(backends, platform, osRelease, { hasCommand, getUid }).slice(0, 3))
         output.write(`  ${line}\n`);
+    const rehearsals = await verifyPlayback(backends, { platform, env });
+    for (const rehearsal of rehearsals)
+        output.write(`  decoder_${rehearsal.backend}=${rehearsal.status} ${rehearsal.message}\n`);
+    if (rehearsals.length === 0)
+        output.write('  decoder=unverified No local playback backend is available for a rehearsal.\n');
+    output.write('  physical_output=unverified Play a station on your intended speakers, headphones, or AirPlay receiver to verify that path.\n');
+    if (rehearsals.some(item => item.status !== 'passed'))
+        output.write('  Playback needs attention. Run radiocli doctor --playback for a repeatable local check.\n');
     output.write('\nRun radiocli to start listening.\n');
 }
 function writeHeader(output) {
     output.write(`${accent(output, 'RADIOCLI')}  SETUP RECEIVER\n`);
-    output.write(`${accent(output, '━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━')}\n`);
-}
-function platformLabel(platform, osRelease) {
-    if (platform === 'darwin')
-        return `${process.arch === 'arm64' ? 'macOS Apple Silicon' : 'macOS'}`;
-    if (platform === 'win32')
-        return 'Windows';
-    if (platform === 'linux')
-        return osReleaseValue(osRelease, 'PRETTY_NAME') || 'Linux';
-    return platform;
-}
-function componentLabel(component) {
-    if (component === 'ffmpeg')
-        return 'FFmpeg / ffplay';
-    if (component === 'vlc')
-        return 'VLC fallback';
-    return 'mpv';
+    output.write(`${accent(output, setupTerminal(output).unicode ? '━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━' : '------------------------------------')}\n`);
 }
 function isInteractive(input, output) {
     return Boolean(input.isTTY && output.isTTY);
 }
 function accent(output, value) {
-    return colorsEnabled(output) ? `\u001b[38;2;116;242;138m${value}\u001b[0m` : value;
+    const level = setupTerminal(output).colorLevel;
+    const color = level === 3 ? '38;2;116;242;138' : level === 2 ? '38;5;120' : '32';
+    return level > 0 ? `\u001b[${color}m${value}\u001b[0m` : value;
 }
 function successMark(output) {
-    return accent(output, '✓');
+    return accent(output, setupTerminal(output).unicode ? '✓' : '+');
 }
 function pendingMark(output) {
-    return accent(output, '◆');
+    return accent(output, setupTerminal(output).unicode ? '◆' : '*');
 }
 function failureMark(output) {
-    return colorsEnabled(output) ? '\u001b[38;2;255;95;135m✗\u001b[0m' : '✗';
+    const terminal = setupTerminal(output);
+    const value = terminal.unicode ? '✗' : 'x';
+    const color = terminal.colorLevel === 3 ? '38;2;255;95;135' : terminal.colorLevel === 2 ? '38;5;204' : '31';
+    return terminal.colorLevel > 0 ? `\u001b[${color}m${value}\u001b[0m` : value;
 }
-function colorsEnabled(output) {
-    return Boolean(output.isTTY) && !process.env.NO_COLOR;
+function setupTerminal(output) {
+    const stream = output;
+    return resolveTerminalCapabilities(process.env, { isTTY: Boolean(stream.isTTY), colorDepth: stream.getColorDepth?.() });
+}
+function separator(output) {
+    return setupTerminal(output).unicode ? '·' : '-';
 }
 function clearLine() {
     return '\u001b[2K';
@@ -428,35 +455,3 @@ async function runVisibleCommand(program, args) {
         child.once('close', code => code === 0 ? resolve() : reject(new Error(`${program} ${args.join(' ')} exited with code ${code}.`)));
     });
 }
-function firstAvailable(values, hasCommand) {
-    return values.find(hasCommand) ?? null;
-}
-function readLinuxOsRelease(platform) {
-    if (platform !== 'linux' || !existsSync('/etc/os-release'))
-        return '';
-    try {
-        return readFileSync('/etc/os-release', 'utf8');
-    }
-    catch {
-        return '';
-    }
-}
-function linuxReleaseIds(osRelease) {
-    const ids = new Set();
-    for (const line of osRelease.split('\n')) {
-        const match = /^(ID|ID_LIKE)=(.*)$/.exec(line);
-        if (!match)
-            continue;
-        for (const value of match[2].replaceAll('"', '').split(/\s+/))
-            if (value.trim())
-                ids.add(value.trim().toLowerCase());
-    }
-    return ids;
-}
-function osReleaseValue(osRelease, key) {
-    const line = osRelease.split('\n').find(candidate => candidate.startsWith(`${key}=`));
-    return line?.slice(key.length + 1).replace(/^"|"$/g, '') ?? '';
-}
-function hasAny(values, candidates) {
-    return candidates.some(candidate => values.has(candidate));
-}

package/dist/storage/file-lock.js

@@ -0,0 +1,113 @@
+import { mkdirSync, readdirSync, renameSync, rmdirSync, unlinkSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { randomUUID } from 'node:crypto';
+import { performance } from 'node:perf_hooks';
+/** An owner is never evicted for being slow. Only a positively dead PID or an
+ * explicitly released generation can be reclaimed. Unknown/legacy locks fail
+ * closed; their age cannot distinguish a crashed writer from a suspended one. */
+export function acquireFileLock(directory, timeoutMs = 1000) {
+    const marker = `owner-${process.pid}-${randomUUID()}`;
+    const deadline = performance.now() + timeoutMs;
+    while (true) {
+        let acquired = false;
+        try {
+            mkdirSync(directory, { mode: 0o700 });
+            acquired = true;
+        }
+        catch (error) {
+            if (codeOf(error) !== 'EEXIST')
+                throw error;
+        }
+        if (acquired) {
+            try {
+                writeFileSync(join(directory, marker), '', { mode: 0o600, flag: 'wx' });
+            }
+            catch (error) {
+                // A failed write can leave its newly created marker behind. Remove only
+                // our unique file; never clear a directory belonging to a later writer.
+                try {
+                    unlinkSync(join(directory, marker));
+                }
+                catch { /* May not have been created. */ }
+                try {
+                    rmdirSync(directory);
+                }
+                catch { /* Never remove another generation. */ }
+                throw error;
+            }
+            let released = false;
+            return () => { if (!released) {
+                released = true;
+                finishLock(directory, marker);
+            } };
+        }
+        try {
+            const entries = readdirSync(directory);
+            const owner = entries.length === 1 ? entries[0] : '';
+            const match = /^(owner|released)-([1-9]\d*)-([a-f\d]{8}(?:-[a-f\d]{4}){3}-[a-f\d]{12})$/.exec(owner);
+            if (match && Number.isSafeInteger(Number(match[2])) && (match[1] === 'released' || isDead(Number(match[2])))) {
+                // Compare and claim the exact marker, never rename/delete the lock
+                // directory after an observation: a different writer may now own it.
+                const reaper = `owner-${process.pid}-${randomUUID()}`;
+                renameSync(join(directory, owner), join(directory, reaper));
+                finishLock(directory, reaper);
+            }
+        }
+        catch (error) {
+            if (codeOf(error) !== 'ENOENT')
+                throw error;
+        }
+        if (performance.now() >= deadline) {
+            throw Object.assign(new Error('The library lock has a live or unknown owner.'), { code: 'EBUSY' });
+        }
+        Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, 10);
+    }
+}
+function isDead(pid) {
+    try {
+        process.kill(pid, 0);
+        return false;
+    }
+    catch (error) {
+        return codeOf(error) === 'ESRCH';
+    }
+}
+function finishLock(directory, marker) {
+    const released = `released-${process.pid}-${randomUUID()}`;
+    try {
+        renameSync(join(directory, marker), join(directory, released));
+    }
+    catch {
+        try {
+            removeOwnedLock(directory, marker);
+        }
+        catch { /* Preserve the transaction result. */ }
+        return;
+    }
+    // Publish completion before cleanup so a failed unlink is recoverable even
+    // while this process is alive. Cleanup must not turn a commit into a failure.
+    try {
+        removeOwnedLock(directory, released);
+    }
+    catch { /* Recover on the next acquisition. */ }
+}
+function removeOwnedLock(directory, marker) {
+    try {
+        unlinkSync(join(directory, marker));
+    }
+    catch (error) {
+        if (codeOf(error) === 'ENOENT')
+            return;
+        throw error;
+    }
+    // An empty directory can be concurrently replaced only by a legacy writer.
+    // rmdir cannot remove a new nonempty generation, unlike recursive rm.
+    try {
+        rmdirSync(directory);
+    }
+    catch (error) {
+        if (!['ENOENT', 'ENOTEMPTY', 'EEXIST'].includes(codeOf(error) ?? ''))
+            throw error;
+    }
+}
+function codeOf(error) { return error?.code; }

package/dist/storage/read-settings.js

@@ -0,0 +1,33 @@
+import { closeSync, constants, fstatSync, openSync, readSync } from 'node:fs';
+/** Bounded, read-only preference inspection. Never creates or repairs a library. */
+export function readSettingsWithoutMigration(path) {
+    if (!path)
+        return undefined;
+    let descriptor;
+    const limit = 2 * 1024 * 1024;
+    try {
+        descriptor = openSync(path, constants.O_RDONLY | constants.O_NONBLOCK);
+        const info = fstatSync(descriptor);
+        if (!info.isFile() || info.size > limit)
+            return undefined;
+        const buffer = Buffer.alloc(limit + 1);
+        const size = readSync(descriptor, buffer, 0, buffer.length, 0);
+        if (size > limit)
+            return undefined;
+        const data = JSON.parse(buffer.toString('utf8', 0, size));
+        if (!record(data))
+            return undefined;
+        return data.settings === undefined ? {} : record(data.settings) ? data.settings : undefined;
+    }
+    catch (error) {
+        return error.code === 'ENOENT' ? {} : undefined;
+    }
+    finally {
+        if (descriptor !== undefined)
+            try {
+                closeSync(descriptor);
+            }
+            catch { /* Read-only best effort. */ }
+    }
+}
+function record(value) { return Boolean(value && typeof value === 'object' && !Array.isArray(value)); }