@ciphore/radiocli 0.2.2 → 0.2.4

package/dist/setup.js

@@ -1,47 +1,86 @@
+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 } 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 { defaultAgentControlSettings } from './types.js';
+import { resolveTerminalCapabilities } from './platform/terminal.js';
+import { identifyPlatform, readLinuxOsRelease } from './platform/runtime.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 ?? []);
+    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 });
     }
-    const plan = createSetupPlan({ platform, osRelease, packageManager, installed, selected });
+    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);
+    }
+    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 isRoot = (options.getUid ?? process.getuid)?.() === 0;
+    const elevation = packageManagerElevation(hasCommand, isRoot);
+    const plan = createSetupPlan({ platform, osRelease, env, packageManager, installed, selected, elevation });
     printPlan(plan, output);
+    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 missing = plan.selected.filter(component => !plan.installed[component]);
     if (missing.length === 0) {
         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);
         return;
     }
     if (!plan.packageManager) {
         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);
             return;
         }
         throw new Error('No supported system package manager was found. Install mpv manually, then run radiocli doctor.');
     }
     if (parsed.dryRun) {
         output.write('\nDry run complete. No system packages were changed.\n');
+        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 (packageManagerNeedsRoot(plan.packageManager) && !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 (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);
@@ -55,59 +94,44 @@ export async function runSetup(options = {}) {
     }
     if (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;
+    const execute = options.runCommand ?? ((command, destination) => runInstallCommand(command, destination, platform));
     output.write('\nInstalling\n');
     for (const command of plan.commands) {
         await execute(command, output);
     }
     clearCommandCache();
     output.write('\nSetup complete.\n');
+    await finishMcpSetup(mcp, agentUi, false, output);
     printVerification(output);
 }
-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;
@@ -115,6 +139,8 @@ export function parseSetupArgs(args) {
     let yes = false;
     let only = null;
     let packageManager = null;
+    let mcp = null;
+    let agentUi = null;
     for (let index = 0; index < args.length; index += 1) {
         const arg = args[index];
         if (arg === '--all')
@@ -123,6 +149,26 @@ export function parseSetupArgs(args) {
             dryRun = true;
         else if (arg === '--yes' || arg === '-y')
             yes = true;
+        else if (arg === '--mcp') {
+            if (mcp === false)
+                throw new Error('Use either --mcp or --no-mcp, not both.');
+            mcp = true;
+        }
+        else if (arg === '--no-mcp') {
+            if (mcp === true)
+                throw new Error('Use either --mcp or --no-mcp, not both.');
+            mcp = false;
+        }
+        else if (arg === '--agent-ui') {
+            if (agentUi === false)
+                throw new Error('Use either --agent-ui or --headless-agent, not both.');
+            agentUi = true;
+        }
+        else if (arg === '--headless-agent') {
+            if (agentUi === true)
+                throw new Error('Use either --agent-ui or --headless-agent, not both.');
+            agentUi = false;
+        }
         else if (arg === '--only')
             only = parseComponents(args[++index]);
         else if (arg.startsWith('--only='))
@@ -136,7 +182,36 @@ export function parseSetupArgs(args) {
     }
     if (all && only)
         throw new Error('Use either --all or --only, not both.');
-    return { all, dryRun, yes, only, packageManager };
+    if (agentUi !== null && mcp !== true)
+        throw new Error('--agent-ui and --headless-agent require --mcp.');
+    return { all, dryRun, yes, only, packageManager, mcp, agentUi };
+}
+async function finishMcpSetup(enabled, agentUi, dryRun, output) {
+    if (enabled === null)
+        return;
+    if (dryRun) {
+        output.write(`\nAgent integration: would be ${enabled ? 'enabled and installed for detected MCP clients' : 'disabled and removed from detected MCP clients'}.\n`);
+        return;
+    }
+    const entry = process.argv[1];
+    if (!entry)
+        throw new Error('Could not locate the RadioCLI executable for MCP setup.');
+    const results = await configureMcpIntegrations(enabled, { nodePath: process.execPath, cliPath: realpathSync(entry) }, output);
+    const failed = results.filter(result => result.status === 'failed');
+    if (failed.length > 0) {
+        throw new Error(`Playback setup finished, but ${failed.length} agent integration${failed.length === 1 ? '' : 's'} failed: ${failed.map(result => result.client).join(', ')}. Run radiocli mcp status for details.`);
+    }
+    if (enabled) {
+        const store = new JsonLibraryStore();
+        const current = store.snapshot().settings.agentControl ?? defaultAgentControlSettings;
+        const openUiOnPlay = agentUi ?? current.openUiOnPlay;
+        if (openUiOnPlay !== current.openUiOnPlay) {
+            store.updateSettings({ agentControl: { ...current, openUiOnPlay } });
+        }
+        output.write(openUiOnPlay
+            ? '\nAgent playback: terminal TUI enabled (default). The host OS may request app-control permission on first use.\n'
+            : '\nAgent playback: headless; no separate terminal window or app-control permission is needed.\n');
+    }
 }
 function parseComponents(value) {
     const values = value?.split(',').map(item => item.trim().toLowerCase()).filter(Boolean) ?? [];
@@ -151,51 +226,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];
@@ -211,11 +241,11 @@ function detectInstalledComponents(hasCommand) {
 async function promptForComponents({ platform, installed, input, output }) {
     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 promptYesNo(input, output, `  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 promptYesNo(input, output, `  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 promptYesNo(input, output, `  VLC      Additional playback fallback${installed.vlc ? ` ${separator(output)} installed` : ''}`, false))
         selected.push('vlc');
     return selected;
 }
@@ -233,19 +263,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;
@@ -261,7 +295,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);
@@ -289,8 +324,9 @@ 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) {
     clearCommandCache();
@@ -303,41 +339,34 @@ function printVerification(output) {
 }
 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 setupTerminal(output) {
+    const stream = output;
+    return resolveTerminalCapabilities(process.env, { isTTY: Boolean(stream.isTTY), colorDepth: stream.getColorDepth?.() });
 }
-function colorsEnabled(output) {
-    return Boolean(output.isTTY) && !process.env.NO_COLOR;
+function separator(output) {
+    return setupTerminal(output).unicode ? '·' : '-';
 }
 function clearLine() {
     return '\u001b[2K';
@@ -359,35 +388,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));
-}