@ciphore/radiocli 0.2.4 → 0.2.5

package/dist/platform/mpris.js

@@ -0,0 +1,356 @@
+import { createHash } from 'node:crypto';
+import { createConnection as connectSocket } from 'node:net';
+const objectPath = '/org/mpris/MediaPlayer2';
+const rootInterface = 'org.mpris.MediaPlayer2';
+const playerInterface = `${rootInterface}.Player`;
+const propertiesInterface = 'org.freedesktop.DBus.Properties';
+/** Only local Unix transports are accepted. Never hand a unixexec or TCP
+ * address to the dependency's address parser. Node handles abstract sockets. */
+export function sessionBusSocket(address) {
+    if (address.length > 4096 || /[\0\r\n]/.test(address))
+        return null;
+    for (const entry of address.split(';')) {
+        if (!entry.startsWith('unix:'))
+            continue;
+        const values = new Map();
+        try {
+            for (const part of entry.slice(5).split(',')) {
+                const at = part.indexOf('=');
+                if (at <= 0)
+                    throw new Error('Invalid bus address');
+                const key = part.slice(0, at);
+                if (values.has(key))
+                    throw new Error('Duplicate bus address key');
+                values.set(key, decodeURIComponent(part.slice(at + 1)));
+            }
+        }
+        catch {
+            continue;
+        }
+        const path = values.get('path');
+        const abstract = values.get('abstract');
+        if (path && !abstract && path.startsWith('/') && !/[\0\r\n]/.test(path) && Buffer.byteLength(path) < 108)
+            return path;
+        if (abstract && !path && !/[\0\r\n]/.test(abstract) && Buffer.byteLength(abstract) < 107)
+            return `\0${abstract}`;
+    }
+    return null;
+}
+export function mprisServiceName(identity) {
+    return `${rootInterface}.radiocli.h${createHash('sha256').update(identity).digest('hex').slice(0, 24)}`;
+}
+export function mprisProperties(snapshot) {
+    const { playback, station, queue } = snapshot;
+    const active = snapshot.available && playback.ready && ['playing', 'paused'].includes(playback.state);
+    const selected = snapshot.available && Boolean(station) && (active || ['idle', 'stopped'].includes(playback.state));
+    const pause = selected && playback.backend === 'mpv';
+    const metadata = [];
+    if (selected && station) {
+        metadata.push(['mpris:trackid', ['o', `/org/radiocli/track/t${createHash('sha256').update(`${station.provider}\0${station.id}`).digest('hex').slice(0, 24)}`]]);
+        metadata.push(['xesam:title', ['s', publicText(snapshot.title) || publicText(station.name) || 'RadioCLI']]);
+        const stationName = publicText(station.name);
+        if (stationName)
+            metadata.push(['xesam:album', ['s', stationName]]);
+    }
+    return {
+        root: {
+            CanQuit: ['b', false], CanRaise: ['b', false], HasTrackList: ['b', false],
+            Identity: ['s', 'RadioCLI'], SupportedUriSchemes: ['as', []], SupportedMimeTypes: ['as', []]
+        },
+        player: {
+            PlaybackStatus: ['s', active ? playback.state === 'paused' ? 'Paused' : 'Playing' : 'Stopped'],
+            Rate: ['d', 1], Metadata: ['a{sv}', metadata], Volume: ['d', playback.muted ? 0 : Math.max(0, Math.min(1, playback.volume / 100))],
+            Position: ['x', 0], MinimumRate: ['d', 1], MaximumRate: ['d', 1],
+            CanGoNext: ['b', selected && queue.length > 1], CanGoPrevious: ['b', selected && queue.length > 1],
+            CanPlay: ['b', selected], CanPause: ['b', pause], CanSeek: ['b', false], CanControl: ['b', snapshot.available]
+        }
+    };
+}
+function publicText(value) {
+    // Broadcast text is untrusted; URI/path-shaped metadata can contain tokens.
+    return (value ?? '').replace(/[\x00-\x1f\x7f-\x9f]/g, '').replace(/(?:[a-z][a-z0-9+.-]*:\/\/|\bfile:|\b[a-z]:[\\/]|(?:^|\s)[/~\\])\S*/gi, '').trim().slice(0, 512);
+}
+/** A small, typed MPRIS endpoint. Closing the private connection releases its
+ * name, so no ReleaseName race can release a replacement owner's service. */
+export function startMpris(options) {
+    const path = sessionBusSocket(options.address);
+    let disposed = false;
+    let generation = 0;
+    let connection;
+    let connected = false;
+    let registered = false;
+    let starting = false;
+    let serial = 1;
+    let retries = 0;
+    let timer;
+    let lastProperties = '';
+    const pending = new Map();
+    const available = () => !disposed && options.snapshot().available;
+    const send = (message) => {
+        if (connected && connection && !connection.stream.destroyed)
+            connection.message({ ...message, serial: serial++ });
+    };
+    const disconnect = () => {
+        generation += 1;
+        registered = false;
+        starting = false;
+        connected = false;
+        if (timer)
+            clearTimeout(timer);
+        timer = undefined;
+        for (const request of pending.values()) {
+            clearTimeout(request.timer);
+            request.reject();
+        }
+        pending.clear();
+        connection?.stream.destroy();
+        connection = undefined;
+    };
+    const retry = () => {
+        disconnect();
+        if (!available())
+            return;
+        timer = setTimeout(() => { timer = undefined; void start(); }, Math.min(30_000, 500 * 2 ** Math.min(6, retries++)));
+        timer.unref();
+    };
+    const call = (member, signature = '', body = []) => new Promise((resolve, reject) => {
+        if (!connected || !connection || connection.stream.destroyed) {
+            reject(new Error('Session bus disconnected.'));
+            return;
+        }
+        const id = serial++;
+        const timeout = setTimeout(() => { pending.delete(id); reject(new Error('Session bus did not respond.')); }, 2000);
+        timeout.unref();
+        pending.set(id, { resolve, reject: () => reject(new Error('Session bus disconnected.')), timer: timeout });
+        connection.message({ type: 1, serial: id, path: '/org/freedesktop/DBus', destination: 'org.freedesktop.DBus', interface: 'org.freedesktop.DBus', member, signature, body });
+    });
+    const error = (request, name, detail) => send({ type: 3, destination: request.sender, replySerial: request.serial, errorName: `org.freedesktop.DBus.Error.${name}`, signature: 's', body: [detail] });
+    const reply = (request, signature = '', body = []) => send({ type: 2, destination: request.sender, replySerial: request.serial, signature, body });
+    const receive = async (request, current) => {
+        if (current !== generation || disposed)
+            return;
+        if (request.type === 2 || request.type === 3) {
+            const handler = request.replySerial === undefined ? undefined : pending.get(request.replySerial);
+            if (handler) {
+                pending.delete(request.replySerial);
+                clearTimeout(handler.timer);
+                if (request.type === 2)
+                    handler.resolve(request.body ?? []);
+                else
+                    handler.reject();
+            }
+            return;
+        }
+        if (request.type !== 1 || !registered)
+            return;
+        if (request.path !== objectPath) {
+            error(request, 'UnknownObject', 'Unknown object.');
+            return;
+        }
+        try {
+            if (request.interface === 'org.freedesktop.DBus.Introspectable' && request.member === 'Introspect' && !request.signature) {
+                reply(request, 's', [introspection]);
+                return;
+            }
+            if (request.interface === 'org.freedesktop.DBus.Peer' && request.member === 'Ping' && !request.signature) {
+                reply(request);
+                return;
+            }
+            const properties = mprisProperties(options.snapshot());
+            if (request.interface === propertiesInterface) {
+                const [iface, property, value] = request.body ?? [];
+                const values = iface === rootInterface ? properties.root : iface === playerInterface ? properties.player : null;
+                if (!values) {
+                    error(request, 'UnknownInterface', 'Unknown interface.');
+                    return;
+                }
+                if (request.member === 'GetAll' && request.signature === 's') {
+                    reply(request, 'a{sv}', [Object.entries(values)]);
+                    return;
+                }
+                if (typeof property !== 'string' || !Object.hasOwn(values, property)) {
+                    error(request, 'UnknownProperty', 'Unknown property.');
+                    return;
+                }
+                if (request.member === 'Get' && request.signature === 'ss') {
+                    reply(request, 'v', [values[property]]);
+                    return;
+                }
+                if (request.member === 'Set' && request.signature === 'ssv') {
+                    if (iface === playerInterface && property === 'Rate') {
+                        const rate = doubleVariant(value);
+                        if (rate === 1)
+                            reply(request);
+                        else if (rate === 0) {
+                            const result = await options.command({ type: 'desktop-transport', action: 'pause' });
+                            if (!result.ok)
+                                throw new Error('Control unavailable.');
+                            if (current === generation) {
+                                reply(request);
+                                refresh();
+                            }
+                        }
+                        else
+                            error(request, 'NotSupported', 'Live radio plays at its broadcast rate.');
+                        return;
+                    }
+                    if (iface !== playerInterface || property !== 'Volume') {
+                        error(request, 'PropertyReadOnly', 'Property cannot be changed.');
+                        return;
+                    }
+                    const volume = doubleVariant(value);
+                    if (volume === null) {
+                        error(request, 'InvalidArgs', 'Volume must be a finite double.');
+                        return;
+                    }
+                    const result = await options.command({ type: 'set-volume', volume: Math.min(1, Math.max(0, volume)) * 100, unmute: true });
+                    if (!result.ok)
+                        throw new Error('Control unavailable.');
+                    if (current === generation) {
+                        reply(request);
+                        refresh();
+                    }
+                    return;
+                }
+                error(request, 'InvalidArgs', 'Invalid properties request.');
+                return;
+            }
+            if (request.interface === playerInterface && (request.member === 'Seek' && request.signature === 'x' || request.member === 'SetPosition' && request.signature === 'ox')) {
+                reply(request);
+                return;
+            }
+            if (request.interface !== playerInterface || request.signature) {
+                error(request, 'NotSupported', 'This action is not supported for live radio.');
+                return;
+            }
+            let action;
+            switch (request.member) {
+                case 'Next':
+                    action = 'next';
+                    break;
+                case 'Previous':
+                    action = 'previous';
+                    break;
+                case 'Pause':
+                    action = 'pause';
+                    break;
+                case 'Play':
+                    action = 'play';
+                    break;
+                case 'PlayPause':
+                    action = 'toggle';
+                    break;
+                case 'Stop':
+                    action = 'stop';
+                    break;
+            }
+            if (!action) {
+                error(request, 'NotSupported', 'This action is currently unavailable.');
+                return;
+            }
+            const result = await options.command({ type: 'desktop-transport', action });
+            if (!result.ok)
+                throw new Error('Control unavailable.');
+            if (current === generation) {
+                reply(request);
+                refresh();
+            }
+        }
+        catch {
+            if (current === generation)
+                error(request, 'Failed', 'RadioCLI could not complete the control request.');
+        }
+    };
+    const start = async () => {
+        if (!path || !available() || connection || timer || starting)
+            return;
+        starting = true;
+        const current = ++generation;
+        try {
+            const created = await (options.connect ?? nativeConnection)(path);
+            if (disposed || current !== generation || !available()) {
+                created.stream.destroy();
+                return;
+            }
+            connection = created;
+            created.on('error', () => { if (current === generation)
+                retry(); });
+            created.on('end', () => { if (current === generation)
+                retry(); });
+            created.stream.on('close', () => { if (current === generation)
+                retry(); });
+            created.on('message', message => { void receive(message, current); });
+            timer = setTimeout(() => { if (current === generation)
+                retry(); }, 2000);
+            timer.unref();
+            created.once('connect', () => {
+                if (current !== generation || connection !== created || !available()) {
+                    created.stream.destroy();
+                    return;
+                }
+                connected = true;
+                if (timer)
+                    clearTimeout(timer);
+                timer = undefined;
+                void (async () => {
+                    await call('Hello');
+                    if (current !== generation)
+                        return;
+                    const [result] = await call('RequestName', 'su', [mprisServiceName(options.identity), 4]);
+                    if (current !== generation)
+                        return;
+                    // DO_NOT_QUEUE: never replace or wait in the ownership queue.
+                    if (result !== 1) {
+                        retry();
+                        return;
+                    }
+                    registered = true;
+                    starting = false;
+                    retries = 0;
+                    lastProperties = '';
+                    refresh();
+                })().catch(() => { if (current === generation)
+                    retry(); });
+            });
+        }
+        catch {
+            if (current === generation)
+                retry();
+        }
+    };
+    const refresh = () => {
+        if (!available()) {
+            disconnect();
+            return;
+        }
+        if (!registered) {
+            void start();
+            return;
+        }
+        const properties = mprisProperties(options.snapshot()).player;
+        // Position is not a clock for a live broadcast and does not emit changes.
+        const changed = Object.entries(properties).filter(([name]) => name !== 'Position' && name !== 'CanControl');
+        const encoded = JSON.stringify(changed);
+        if (encoded === lastProperties)
+            return;
+        lastProperties = encoded;
+        send({ type: 4, path: objectPath, interface: propertiesInterface, member: 'PropertiesChanged', signature: 'sa{sv}as', body: [playerInterface, changed, []] });
+    };
+    void start();
+    return { refresh, close() { disposed = true; disconnect(); } };
+}
+async function nativeConnection(path) {
+    const module = await import('@homebridge/dbus-native');
+    const factory = module.default;
+    const stream = connectSocket(path);
+    return factory.createConnection({ stream, authMethods: ['EXTERNAL'] });
+}
+function doubleVariant(value) {
+    if (!Array.isArray(value) || !Array.isArray(value[0]) || !Array.isArray(value[1]))
+        return null;
+    const [type] = value[0];
+    const [number] = value[1];
+    return value[0].length === 1 && type?.type === 'd' && typeof number === 'number' && Number.isFinite(number) ? number : null;
+}
+const propertyXml = (values, writable = []) => Object.entries(values).map(([name, type]) => `<property name="${name}" type="${type}" access="${writable.includes(name) ? 'readwrite' : 'read'}"/>`).join('');
+const introspection = `<node><interface name="org.freedesktop.DBus.Introspectable"><method name="Introspect"><arg direction="out" type="s"/></method></interface><interface name="org.freedesktop.DBus.Peer"><method name="Ping"/></interface><interface name="${propertiesInterface}"><method name="Get"><arg direction="in" type="s"/><arg direction="in" type="s"/><arg direction="out" type="v"/></method><method name="GetAll"><arg direction="in" type="s"/><arg direction="out" type="a{sv}"/></method><method name="Set"><arg direction="in" type="s"/><arg direction="in" type="s"/><arg direction="in" type="v"/></method><signal name="PropertiesChanged"><arg type="s"/><arg type="a{sv}"/><arg type="as"/></signal></interface><interface name="${rootInterface}"><method name="Raise"/><method name="Quit"/>${propertyXml({ CanQuit: 'b', CanRaise: 'b', HasTrackList: 'b', Identity: 's', SupportedUriSchemes: 'as', SupportedMimeTypes: 'as' })}</interface><interface name="${playerInterface}">${['Next', 'Previous', 'Pause', 'PlayPause', 'Stop', 'Play'].map(name => `<method name="${name}"/>`).join('')}<method name="Seek"><arg direction="in" type="x"/></method><method name="SetPosition"><arg direction="in" type="o"/><arg direction="in" type="x"/></method><method name="OpenUri"><arg direction="in" type="s"/></method>${propertyXml({ PlaybackStatus: 's', Rate: 'd', Metadata: 'a{sv}', Volume: 'd', Position: 'x', MinimumRate: 'd', MaximumRate: 'd', CanGoNext: 'b', CanGoPrevious: 'b', CanPlay: 'b', CanPause: 'b', CanSeek: 'b', CanControl: 'b' }, ['Volume', 'Rate'])}</interface></node>`;

package/dist/platform/network.js

@@ -1,5 +1,6 @@
 import { resolve4, resolve6 } from 'node:dns/promises';
 import { request as requestHttps } from 'node:https';
+import { parseJsonAsync } from './json-worker.js';
 const maxResolvedResponseBytes = 128 * 1024 * 1024;
 export function networkPolicy(env = process.env) {
     return { offline: env.RADIOCLI_OFFLINE === '1', lowBandwidth: env.RADIOCLI_LOW_BANDWIDTH === '1' };
@@ -26,7 +27,7 @@ export function networkDiagnostic() {
     }
 }
 /** Keep the request deadline active through body consumption, including errors. */
-export async function withExternalResponse(url, { timeoutMs, init = {}, fetchImpl = fetch }, consume) {
+export async function withExternalResponse(url, { timeoutMs, init = {}, fetchImpl = fetch, maxResponseBytes = maxResolvedResponseBytes }, consume) {
     if (networkPolicy().offline)
         throw new Error('RadioCLI is offline (RADIOCLI_OFFLINE=1).');
     validateProxyConfiguration(new URL(url));
@@ -45,6 +46,7 @@ export async function withExternalResponse(url, { timeoutMs, init = {}, fetchImp
         try {
             // A custom fetch can resolve after the deadline without observing abort.
             signal.throwIfAborted();
+            response = boundedResponse(response, maxResponseBytes, signal);
             return await consume(response);
         }
         finally {
@@ -62,6 +64,72 @@ export async function withExternalResponse(url, { timeoutMs, init = {}, fetchImp
             cancelBody(response);
     }
 }
+/** Count actual decoded body bytes, including chunked responses and deceptive
+ * content lengths. Preserve redirects used by playlist/import consumers. */
+function boundedResponse(response, maxBytes, signal) {
+    if (!Number.isSafeInteger(maxBytes) || maxBytes < 1)
+        throw new Error('Response size limit must be a positive number of bytes.');
+    if (!response.body)
+        return response;
+    const length = Number(response.headers.get('content-length'));
+    if (Number.isFinite(length) && length > maxBytes)
+        throw responseSizeError(maxBytes);
+    const reader = response.body.getReader();
+    let bytes = 0;
+    let ended = false;
+    let controller;
+    const cleanup = () => signal.removeEventListener('abort', aborted);
+    const aborted = () => {
+        if (ended)
+            return;
+        ended = true;
+        cleanup();
+        controller.error(signal.reason);
+        void reader.cancel(signal.reason).catch(() => undefined);
+    };
+    const body = new ReadableStream({
+        start(value) { controller = value; signal.addEventListener('abort', aborted, { once: true }); },
+        async pull(value) {
+            try {
+                const chunk = await reader.read();
+                if (ended)
+                    return;
+                if (chunk.done) {
+                    ended = true;
+                    cleanup();
+                    value.close();
+                    return;
+                }
+                bytes += chunk.value.byteLength;
+                if (bytes > maxBytes) {
+                    ended = true;
+                    cleanup();
+                    const error = responseSizeError(maxBytes);
+                    value.error(error);
+                    void reader.cancel(error).catch(() => undefined);
+                    return;
+                }
+                value.enqueue(chunk.value);
+            }
+            catch (error) {
+                if (!ended) {
+                    ended = true;
+                    cleanup();
+                    value.error(error);
+                }
+            }
+        },
+        cancel(reason) { ended = true; cleanup(); void reader.cancel(reason).catch(() => undefined); }
+    });
+    const bounded = new Response(body, { status: response.status, statusText: response.statusText, headers: response.headers });
+    for (const key of ['url', 'redirected', 'type'])
+        Object.defineProperty(bounded, key, { value: response[key] });
+    Object.defineProperty(bounded, 'json', { value: async () => parseJsonAsync(await bounded.text(), signal) });
+    return bounded;
+}
+function responseSizeError(maxBytes) {
+    return new Error(`HTTP response exceeded the ${maxBytes} byte safety limit.`);
+}
 /**
  * HTTPS fetch fallback for systems where libc getaddrinfo() reports EAI_AGAIN
  * but Node's DNS-protocol resolver can still reach the configured nameserver.

package/dist/platform/omarchy.js

@@ -0,0 +1,147 @@
+import { spawnSync } from 'node:child_process';
+import { closeSync, constants, fstatSync, openSync, readSync, statSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { posix } from 'node:path';
+import { resolveCommandDetails } from './executables.js';
+import { identifyPlatform } from './runtime.js';
+const packagedRoot = '/usr/share/omarchy';
+const maxProbeBytes = 4096;
+const probeTimeoutMs = 500;
+const installationCache = new Map();
+const probeIdentities = new WeakMap();
+let nextProbeIdentity = 0;
+const absent = { kind: 'none', version: null, major: null, source: null, root: null, packageName: null };
+/** Omarchy is desktop evidence, not a replacement for the Linux platform ID. */
+export function identifyOmarchy(options = {}) {
+    const platform = options.platform ?? process.platform;
+    const env = options.env ?? process.env;
+    const remote = Boolean(env.SSH_CONNECTION?.trim() || env.SSH_CLIENT?.trim() || env.SSH_TTY?.trim() || /^(?:1|true|yes)$/i.test(env.XDG_SESSION_REMOTE ?? ''));
+    const headless = /^(?:tty|unspecified)$/i.test(env.XDG_SESSION_TYPE ?? '');
+    const type = !headless && env.WAYLAND_DISPLAY?.trim() ? 'wayland' : !headless && env.DISPLAY?.trim() ? 'x11' : 'headless';
+    const session = { type, remote, localDesktop: !remote && type !== 'headless' };
+    const unavailable = { available: false, command: null, missing: [] };
+    const injected = Boolean(options.readFile || options.isDirectory || options.run);
+    // Cross-platform callers/tests must not inspect the execution host's files.
+    if (identifyPlatform({ platform, env }).id !== 'linux' || platform !== process.platform && !injected) {
+        return { ...absent, session, terminal: unavailable };
+    }
+    const resolve = options.resolve ?? (command => resolveCommandDetails(command, { platform, env }).path ?? undefined);
+    const home = options.home ?? env.HOME ?? homedir();
+    const readFile = options.readFile ?? readSmallFile;
+    const isDirectory = options.isDirectory ?? directoryExists;
+    const run = options.run ?? probeCommand;
+    const now = (options.now ?? Date.now)();
+    const key = [home, env.OMARCHY_PATH, env.PATH, options.resolve, readFile, isDirectory, run].map(value => typeof value === 'function' ? probeIdentity(value) : value).join('\0');
+    // Cache installation probes, but revalidate launcher executables/session on
+    // every request so saved alarm selectors do not retain stale capabilities.
+    const cached = installationCache.get(key);
+    const installation = cached && now >= cached.checkedAt && now - cached.checkedAt < 5000 ? cached.installation
+        : detectInstallation({ env, home, resolve, readFile, isDirectory, run });
+    if (installation !== cached?.installation) {
+        if (installationCache.size >= 32)
+            installationCache.clear();
+        installationCache.set(key, { checkedAt: now, installation });
+    }
+    if (installation.kind !== 'quattro')
+        return { ...installation, session, terminal: unavailable };
+    const command = resolveAbsolute(resolve, posix.join(packagedRoot, 'bin', 'omarchy-launch-tui')) ?? resolveAbsolute(resolve, 'omarchy-launch-tui');
+    // The upstream script invokes these by name. Fallback executable discovery
+    // outside PATH cannot establish that its unchanged environment can run them.
+    const missing = ['setsid', 'uwsm-app', 'xdg-terminal-exec'].filter(name => !reachableOnPath(resolve, name, env.PATH));
+    if (!command)
+        missing.unshift('omarchy-launch-tui');
+    if (!session.localDesktop || type !== 'wayland')
+        missing.push('local-wayland-session');
+    if (!env.DBUS_SESSION_BUS_ADDRESS?.trim())
+        missing.push('session-bus');
+    return { ...installation, session, terminal: { available: missing.length === 0, command, missing } };
+}
+function detectInstallation(options) {
+    const { env, home, resolve, readFile, isDirectory, run } = options;
+    const configuredRoot = safeAbsolute(env.OMARCHY_PATH);
+    // A custom checkout is deliberately kept separate from the packaged release.
+    if (configuredRoot && configuredRoot !== packagedRoot && isDirectory(configuredRoot)) {
+        const metadata = versionFrom(readFile(posix.join(configuredRoot, 'version')));
+        const helper = resolveAbsolute(resolve, posix.join(configuredRoot, 'bin', 'omarchy-version'));
+        if (metadata || helper)
+            return { kind: metadata?.major === 3 ? 'legacy' : 'development', version: metadata?.version ?? null, major: metadata?.major ?? null, source: metadata ? 'legacy-metadata' : 'helper', root: configuredRoot, packageName: null };
+    }
+    if (isDirectory(packagedRoot)) {
+        const pacman = resolveAbsolute(resolve, 'pacman');
+        if (pacman) {
+            for (const name of ['omarchy-dev', 'omarchy']) {
+                const output = boundedOutput(run(pacman, ['-Q', name], { env, timeout: probeTimeoutMs, maxBuffer: maxProbeBytes }));
+                const match = output && new RegExp(`^${name} ([^\\s]+)$`).exec(output);
+                if (!match)
+                    continue;
+                const version = versionFrom(match[1]);
+                return { kind: name === 'omarchy-dev' ? 'development' : releaseKind(version?.major), version: version?.version ?? match[1], major: version?.major ?? null, source: 'package', root: packagedRoot, packageName: name };
+            }
+        }
+        const helper = resolveAbsolute(resolve, posix.join(packagedRoot, 'bin', 'omarchy-version'));
+        const output = helper ? boundedOutput(run(helper, [], { env: { ...env, OMARCHY_PATH: packagedRoot }, timeout: probeTimeoutMs, maxBuffer: maxProbeBytes })) : null;
+        const version = versionFrom(output);
+        // The packaged helper strips the package name from both omarchy-dev and
+        // omarchy. Its numeric output preserves version diagnostics but cannot
+        // establish the stable channel needed for automatic Quattro integration.
+        return { kind: output?.startsWith('dev') ? 'development' : 'unknown', version: version?.version ?? output, major: version?.major ?? null, source: output ? 'helper' : null, root: packagedRoot, packageName: null };
+    }
+    const legacyRoot = safeAbsolute(posix.join(home, '.local', 'share', 'omarchy'));
+    const metadata = legacyRoot && isDirectory(legacyRoot) ? versionFrom(readFile(posix.join(legacyRoot, 'version'))) : null;
+    if (metadata && legacyRoot)
+        return { kind: metadata.major === 3 ? 'legacy' : 'development', ...metadata, source: 'legacy-metadata', root: legacyRoot, packageName: null };
+    return { ...absent };
+}
+function releaseKind(major) { return major === 4 ? 'quattro' : major !== undefined && major < 4 ? 'legacy' : 'unknown'; }
+function probeIdentity(probe) { const current = probeIdentities.get(probe); if (current !== undefined)
+    return current; const next = ++nextProbeIdentity; probeIdentities.set(probe, next); return next; }
+function boundedOutput(value) { const trimmed = value?.trim(); return trimmed && Buffer.byteLength(value, 'utf8') <= maxProbeBytes && !/[\0\r\n]/.test(trimmed) ? trimmed : null; }
+function versionFrom(value) {
+    const version = boundedOutput(value);
+    const match = version && /^(?:\d+:)?(\d+)\.\d+\.\d+(?:-\d+(?:\.\d+)?)?$/.exec(version);
+    return match ? { version: version, major: Number(match[1]) } : null;
+}
+function safeAbsolute(value) { return value && posix.isAbsolute(value) && !/[\0\r\n]/.test(value) ? posix.normalize(value) : null; }
+function resolveAbsolute(resolve, command) { return safeAbsolute(resolve(command)); }
+function reachableOnPath(resolve, command, path) {
+    if (path === undefined || /[\0\r\n]/.test(path))
+        return false;
+    return path.split(':').some(directory => {
+        const candidate = posix.resolve(directory || '.', command);
+        return resolveAbsolute(resolve, candidate) === candidate;
+    });
+}
+function directoryExists(path) { try {
+    return statSync(path).isDirectory();
+}
+catch {
+    return false;
+} }
+function readSmallFile(path) {
+    let descriptor;
+    try {
+        descriptor = openSync(path, constants.O_RDONLY | constants.O_NONBLOCK);
+        const stat = fstatSync(descriptor);
+        if (!stat.isFile() || stat.size > maxProbeBytes)
+            return null;
+        const buffer = Buffer.alloc(maxProbeBytes + 1);
+        const count = readSync(descriptor, buffer, 0, buffer.length, 0);
+        return count > maxProbeBytes ? null : buffer.toString('utf8', 0, count);
+    }
+    catch {
+        return null;
+    }
+    finally {
+        if (descriptor !== undefined)
+            closeSync(descriptor);
+    }
+}
+function probeCommand(command, args, options) {
+    try {
+        const result = spawnSync(command, args, { ...options, killSignal: 'SIGKILL', encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'] });
+        return result.error || result.status !== 0 ? null : boundedOutput(result.stdout);
+    }
+    catch {
+        return null;
+    }
+}

package/dist/platform/packages.js

@@ -1,6 +1,7 @@
 import { commandExists } from './executables.js';
 import { powershellCommand } from './shell.js';
 import { identifyPlatform, readLinuxOsRelease } from './runtime.js';
+import { identifyOmarchy } from './omarchy.js';
 export const packageManagers = ['brew', 'winget', 'scoop', 'choco', 'apt', 'dnf', 'pacman', 'apk', 'zypper', 'pkg', 'pkg_add', 'pkgin', 'termux-pkg', 'pkgman'];
 /** FreeBSD pkg and Termux pkg have distinct recipes and privilege models. */
 export function packageManagerProgram(manager) {
@@ -98,7 +99,12 @@ export function packageInstallCommand(manager, component, { elevation = 'sudo' }
 export function packageManagerNeedsRoot(manager) {
     return !['brew', 'winget', 'scoop', 'choco', 'termux-pkg', 'pkgman'].includes(manager);
 }
-export function packageManagerNotes(manager, host = identifyPlatform()) {
+export function packageManagerNotes(manager, host = identifyPlatform(), omarchy) {
+    if (manager === 'pacman' && host.id === 'linux' && (omarchy ?? identifyOmarchy({ platform: 'linux' })).kind === 'quattro')
+        return [
+            'Omarchy Quattro uses the existing Arch mpv and ffmpeg packages. Native terminal launching requires a local Wayland session, a user session bus, and the Omarchy TUI launcher with setsid, uwsm-app, and xdg-terminal-exec.',
+            'If pacman reports stale databases or package conflicts, complete the supported Omarchy update workflow and rerun setup. RadioCLI setup does not upgrade the distribution or bypass package checks.'
+        ];
     if (manager === 'termux-pkg' || (!manager && host.id === 'termux'))
         return [
             'Termux pkg runs as the normal app user, without sudo or root. Use --package-manager=termux-pkg to select this recipe explicitly.',

package/dist/platform/runtime.js

@@ -34,7 +34,7 @@ export function nativeAdapters(host = identifyPlatform()) {
     if (host.id === 'win32')
         return { ...portable, scheduler: 'task-scheduler', inhibitor: 'windows', volume: 'windows', terminal: 'windows', ipc: 'named-pipe', posixPermissions: false };
     if (host.id === 'linux')
-        return { ...portable, scheduler: 'systemd', inhibitor: 'logind', volume: 'unix-audio', terminal: 'unix' };
+        return { ...portable, scheduler: 'systemd', inhibitor: 'logind', volume: 'unix-audio', terminal: 'unix', airPlay: !host.isWsl };
     if (['freebsd', 'openbsd', 'netbsd'].includes(host.id))
         return { ...portable, terminal: 'unix' };
     return portable;