@ciphore/radiocli 0.2.4 → 0.2.5

package/dist/player/mpv-desktop-media.js

@@ -0,0 +1,194 @@
+import { closeSync, constants, fstatSync, openSync, opendirSync, readSync, realpathSync, statSync } from 'node:fs';
+import { posix } from 'node:path';
+const maxConfigBytes = 256 * 1024;
+const maxScripts = 256;
+const unsupported = (reason) => ({ status: 'unsupported', args: [], reason });
+const compatible = (args, reason) => ({ status: 'compatible', args, reason });
+/**
+ * mpv-mpris 1.3 has no per-process opt-out. Replace directory autoload with its
+ * exact file list, omitting only the packaged plugin. mpv still reads its normal
+ * configuration and loads every unrelated script. Nothing is written to disk.
+ *
+ * Source contracts: mpv player/scripting.c and options/path.c; mpv-mpris Makefile.
+ * Configurations whose script-loading semantics cannot be preserved are left
+ * completely alone; the application media service must then remain disabled.
+ */
+export function planMpvDesktopMedia(options = {}) {
+    if ((options.platform ?? process.platform) !== 'linux')
+        return unsupported('Desktop mpv media integration is available on Linux.');
+    const env = options.env ?? process.env;
+    const executable = options.executable ?? env.RADIOCLI_MPV_PATH ?? '/usr/bin/mpv';
+    if (!options.configDirectories && !['/usr/bin/mpv', '/bin/mpv'].includes(executable)) {
+        return unsupported('Desktop media controls require the packaged mpv configuration layout; the custom mpv executable was left unchanged.');
+    }
+    try {
+        const directories = options.configDirectories ?? configDirectories(env);
+        let stockMprisPath = options.stockMprisPath ?? '/usr/lib/mpv-mpris/mpris.so';
+        try {
+            stockMprisPath = realpathSync(stockMprisPath);
+        }
+        catch (error) {
+            if (error.code !== 'ENOENT')
+                throw error;
+        }
+        let autoload = true;
+        let ambiguous = false;
+        // mpv loads encoding profiles first, then config/mpv.conf in each search
+        // directory. A profile with script options is deliberately not reinterpreted.
+        const files = [
+            ...directories.map(directory => posix.join(directory, 'encoding-profiles.conf')),
+            ...directories.flatMap(directory => ['config', 'mpv.conf'].map(file => posix.join(directory, file)))
+        ];
+        for (const file of files) {
+            const contents = readConfig(file);
+            if (contents === null)
+                continue;
+            let profile = false;
+            for (const raw of contents.split(/\r?\n/)) {
+                const line = raw.trim();
+                if (!line || line.startsWith('#'))
+                    continue;
+                if (line.startsWith('[')) {
+                    profile = !/^\[default\]\s*(?:#.*)?$/.test(line);
+                    continue;
+                }
+                // Includes and script lists can change startup script order or load
+                // another media plugin. Ordinary profiles remain intact; script options
+                // inside any profile are rejected even when that profile is inactive.
+                if (/^(?:--)?(?:include|config(?:-dir)?|use-filedir-conf|scripts?(?:-(?:add|append|clr|del|pre|set|toggle|remove))?)\s*(?:=|$)/i.test(line)) {
+                    ambiguous = true;
+                    continue;
+                }
+                if (/^(?:--)?(?:no-)?load-scripts\b/i.test(line)) {
+                    const setting = /^(?:--)?load-scripts\s*=\s*(yes|no)\s*(?:#.*)?$/i.exec(line);
+                    if (profile || !setting)
+                        ambiguous = true;
+                    else
+                        autoload = setting[1].toLowerCase() === 'yes';
+                }
+            }
+        }
+        if (ambiguous)
+            return unsupported('Custom mpv script, include, or profile directives require native media handling; mpv configuration and scripts were left unchanged.');
+        if (!autoload)
+            return compatible([], 'mpv directory scripts are disabled by the existing configuration.');
+        const scripts = [];
+        let omitted = 0;
+        for (const directory of directories) {
+            const entries = scriptFiles(posix.join(directory, 'scripts'));
+            for (const file of entries) {
+                if (scripts.length + omitted >= maxScripts)
+                    throw new Error('Too many mpv scripts to preserve within the bounded desktop media check.');
+                const actual = realpathSync(file);
+                if (actual === stockMprisPath) {
+                    omitted++;
+                    continue;
+                }
+                if (/^(?:mpv[-_])?mpris(?:\.(?:so|lua|js))?$/i.test(posix.basename(file)) || /^(?:mpv[-_])?mpris(?:\.(?:so|lua|js))?$/i.test(posix.basename(actual))) {
+                    return unsupported('A custom mpv MPRIS plugin needs native media handling; mpv configuration and scripts were left unchanged.');
+                }
+                scripts.push(file);
+            }
+        }
+        if (!omitted)
+            return compatible([], 'No stock mpv media plugin needs suppression.');
+        return compatible(['--load-scripts=no', ...scripts.map(file => `--script=${file}`)], 'The stock mpv media plugin is omitted for this process; other scripts and configuration are preserved.');
+    }
+    catch {
+        return unsupported('mpv script configuration could not be safely inspected; native mpv behavior is preserved.');
+    }
+}
+function configDirectories(env) {
+    if (env.MPV_HOME !== undefined) {
+        if (!env.MPV_HOME)
+            return [];
+        return [absolute(env.MPV_HOME)];
+    }
+    const result = ['/etc/mpv'];
+    const home = env.HOME ? absolute(env.HOME) : null;
+    const modern = env.XDG_CONFIG_HOME?.startsWith('/') ? posix.join(absolute(env.XDG_CONFIG_HOME), 'mpv') : home ? posix.join(home, '.config', 'mpv') : null;
+    const legacy = home ? posix.join(home, '.mpv') : null;
+    if (legacy && isDirectory(legacy))
+        result.push(legacy);
+    if (modern && (modern !== legacy) && (!legacy || !isDirectory(legacy) || isDirectory(modern)))
+        result.push(modern);
+    return result;
+}
+function absolute(value) {
+    if (!posix.isAbsolute(value) || /[\0\r\n]/.test(value))
+        throw new Error('Ambiguous mpv configuration path.');
+    return posix.normalize(value);
+}
+function isDirectory(path) {
+    try {
+        return statSync(path).isDirectory();
+    }
+    catch (error) {
+        if (error.code === 'ENOENT')
+            return false;
+        throw error;
+    }
+}
+function readConfig(path) {
+    let descriptor;
+    try {
+        descriptor = openSync(path, constants.O_RDONLY | constants.O_NONBLOCK);
+        const info = fstatSync(descriptor);
+        if (!info.isFile() || info.size > maxConfigBytes)
+            throw new Error('Unbounded mpv configuration.');
+        const buffer = Buffer.alloc(maxConfigBytes + 1);
+        const size = readSync(descriptor, buffer, 0, buffer.length, 0);
+        if (size > maxConfigBytes)
+            throw new Error('Unbounded mpv configuration.');
+        return buffer.toString('utf8', 0, size);
+    }
+    catch (error) {
+        if (error.code === 'ENOENT')
+            return null;
+        throw error;
+    }
+    finally {
+        if (descriptor !== undefined)
+            closeSync(descriptor);
+    }
+}
+function scriptFiles(directory) {
+    let handle;
+    try {
+        handle = opendirSync(directory);
+    }
+    catch (error) {
+        if (error.code === 'ENOENT')
+            return [];
+        throw error;
+    }
+    const files = [];
+    let inspected = 0;
+    try {
+        for (let entry = handle.readSync(); entry; entry = handle.readSync()) {
+            if (++inspected > 1024 || files.length >= maxScripts)
+                throw new Error('Unbounded mpv script directory.');
+            if (entry.name.startsWith('.'))
+                continue;
+            const path = posix.join(directory, entry.name);
+            let info;
+            try {
+                info = statSync(path);
+            }
+            catch (error) {
+                if (error.code === 'ENOENT')
+                    continue;
+                throw error;
+            }
+            if (info.isFile() || info.isDirectory())
+                files.push(path);
+        }
+    }
+    finally {
+        handle.closeSync();
+    }
+    // Use stable ASCII ordering for explicit scripts, without locale collation.
+    // Native mpv autoload order is not a reliable script dependency contract.
+    const fold = (value) => Buffer.from(value.replace(/[A-Z]/g, letter => letter.toLowerCase()));
+    return files.sort((left, right) => Buffer.compare(fold(left), fold(right)));
+}

package/dist/player/mpv-ipc-client.js

@@ -14,12 +14,25 @@ export class MpvIpcClient {
     connecting = null;
     pending = new Map();
     buffer = '';
+    bufferBytes = 0;
+    bufferScanFrom = 0;
     nextRequestId = 1;
     closed = false;
+    connectedOnce = false;
+    observers = new Map();
+    eventListeners = new Set();
     constructor(path, timeoutMs = 1000) {
         this.path = path;
         this.timeoutMs = timeoutMs;
     }
+    onEvent(listener) {
+        this.eventListeners.add(listener);
+        return () => this.eventListeners.delete(listener);
+    }
+    async observe(id, property) {
+        this.observers.set(id, property);
+        await this.query({ command: ['observe_property', id, property] });
+    }
     async query(payload) {
         if (this.closed) {
             throw new Error('mpv IPC client is closed.');
@@ -54,6 +67,8 @@ export class MpvIpcClient {
             return;
         }
         this.closed = true;
+        this.eventListeners.clear();
+        this.observers.clear();
         this.rejectPending(reason);
         this.socket?.destroy();
         this.connectingSocket?.destroy();
@@ -61,6 +76,8 @@ export class MpvIpcClient {
         this.connectingSocket = null;
         this.connecting = null;
         this.buffer = '';
+        this.bufferBytes = 0;
+        this.bufferScanFrom = 0;
     }
     connect() {
         if (this.socket && !this.socket.destroyed) {
@@ -102,11 +119,19 @@ export class MpvIpcClient {
                 this.socket = socket;
                 this.connectingSocket = null;
                 this.buffer = '';
+                this.bufferBytes = 0;
+                this.bufferScanFrom = 0;
                 socket.setEncoding('utf8');
-                socket.on('data', chunk => this.consume(String(chunk)));
+                socket.on('data', chunk => { if (this.socket === socket)
+                    this.consume(String(chunk)); });
                 socket.on('error', error => this.dropSocket(socket, error));
                 socket.on('close', () => this.dropSocket(socket, new Error('mpv IPC connection closed.')));
                 resolve(socket);
+                if (this.connectedOnce) {
+                    for (const [id, property] of this.observers)
+                        void this.query({ command: ['observe_property', id, property] }).catch(() => undefined);
+                }
+                this.connectedOnce = true;
             };
             socket.once('error', failConnection);
             socket.once('close', closeBeforeConnection);
@@ -127,10 +152,20 @@ export class MpvIpcClient {
     }
     consume(chunk) {
         this.buffer += chunk;
-        let newlineIndex = this.buffer.indexOf('\n');
+        this.bufferBytes += Buffer.byteLength(chunk);
+        if (this.bufferBytes > 4 * 1024 * 1024) {
+            const socket = this.socket;
+            if (socket) {
+                this.dropSocket(socket, new Error('mpv IPC message exceeds 4 MiB.'));
+                socket.destroy();
+            }
+            return;
+        }
+        let newlineIndex = this.buffer.indexOf('\n', this.bufferScanFrom);
         while (newlineIndex !== -1) {
             const line = this.buffer.slice(0, newlineIndex);
             this.buffer = this.buffer.slice(newlineIndex + 1);
+            this.bufferBytes -= Buffer.byteLength(line) + 1;
             newlineIndex = this.buffer.indexOf('\n');
             if (!line.trim()) {
                 continue;
@@ -142,7 +177,18 @@ export class MpvIpcClient {
             catch {
                 continue;
             }
+            if (!response || typeof response !== 'object' || Array.isArray(response))
+                continue;
             if (typeof response.request_id !== 'number' || !this.pending.has(response.request_id)) {
+                const event = response;
+                if (typeof event.event === 'string') {
+                    for (const listener of this.eventListeners) {
+                        try {
+                            listener(event);
+                        }
+                        catch { /* Isolate event consumers. */ }
+                    }
+                }
                 continue;
             }
             if (response.error && response.error !== 'success') {
@@ -152,6 +198,7 @@ export class MpvIpcClient {
                 this.settleRequest(response.request_id, pending => pending.resolve(response.data));
             }
         }
+        this.bufferScanFrom = this.buffer.length;
     }
     dropSocket(socket, error) {
         if (this.socket !== socket) {
@@ -159,6 +206,8 @@ export class MpvIpcClient {
         }
         this.socket = null;
         this.buffer = '';
+        this.bufferBytes = 0;
+        this.bufferScanFrom = 0;
         this.rejectPending(error);
     }
     rejectPending(error) {