@phystack/device-phyos 4.4.45 → 4.4.47

package/dist/utilities/audio-control.js

@@ -0,0 +1,919 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.applyAudioOutputControlAndReport = applyAudioOutputControlAndReport;
+exports.applyAudioInputControlAndReport = applyAudioInputControlAndReport;
+exports.applyAudioOutputControl = applyAudioOutputControl;
+exports.applyAudioInputControl = applyAudioInputControl;
+const child_process_1 = require("child_process");
+const phy_logger_1 = require("@phystack/phy-logger");
+const hub_device_1 = require("@phystack/hub-device");
+const sysinfo_1 = __importDefault(require("@phystack/hub-device/dist/sysinfo"));
+const logger = new phy_logger_1.PhyLogger({
+    logToFile: false,
+    logToConsole: true,
+    includeTrace: true,
+    namespace: 'audio-control.ts',
+});
+const PACTL_COMMANDS = {
+    SET_DEFAULT_SINK: (deviceId) => `pactl set-default-sink ${deviceId}`,
+    SET_DEFAULT_SOURCE: (deviceId) => `pactl set-default-source ${deviceId}`,
+    SET_SINK_VOLUME: (deviceId, volumePercent) => `pactl set-sink-volume ${deviceId} ${volumePercent}%`,
+    SET_SOURCE_VOLUME: (deviceId, volumePercent) => `pactl set-source-volume ${deviceId} ${volumePercent}%`,
+    SET_SINK_MUTE: (deviceId, muteValue) => `pactl set-sink-mute ${deviceId} ${muteValue}`,
+    SET_SOURCE_MUTE: (deviceId, muteValue) => `pactl set-source-mute ${deviceId} ${muteValue}`,
+    SET_SINK_PORT: (deviceId, portName) => `pactl set-sink-port ${deviceId} ${portName}`,
+    SET_SOURCE_PORT: (deviceId, portName) => `pactl set-source-port ${deviceId} ${portName}`,
+    LIST_SINKS_SHORT: () => `pactl list short sinks`,
+    LIST_SOURCES_SHORT: () => `pactl list short sources`,
+    LIST_SINK_INPUTS: () => `pactl list short sink-inputs`,
+    MOVE_SINK_INPUT: (inputId, sinkId) => `pactl move-sink-input ${inputId} ${sinkId}`,
+    CORK_SINK_INPUT: (inputId, uncork) => `pactl cork-sink-input ${inputId} ${uncork ? '0' : '1'}`,
+    SUSPEND_SINK: (deviceId, suspend) => `pactl suspend-sink ${deviceId} ${suspend ? '1' : '0'}`,
+    LIST_CARDS: () => `pactl list cards`,
+    LIST_CARDS_SHORT: () => `pactl list cards short`,
+    GET_SINK_INFO: (sinkId) => `pactl list sinks | grep -A 50 "Name: ${sinkId}"`,
+    GET_CARD_INFO: (cardName) => `pactl list cards | grep -A 100 "Name: ${cardName}"`,
+    SET_CARD_PROFILE: (cardName, profile) => `pactl set-card-profile ${cardName} ${profile}`,
+    CHECK_SINK_EXISTS: (identifier) => `pactl list short sinks | grep "^[0-9]\\+\\s\\+${identifier.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}"`,
+};
+const PACTL_TIMEOUT = 3000;
+function getPulseAudioEnv() {
+    return (0, hub_device_1.getPulseAudioEnv)();
+}
+function getCardNameFromSink(sinkId) {
+    try {
+        const env = getPulseAudioEnv();
+        const match = sinkId.match(/^([^_]+)_(?:output|input|sink|source)\.([^.]+(?:\.[^.]+)*)/);
+        if (match) {
+            const prefix = match[1];
+            const cardIdWithProfile = match[2];
+            const cardIdMatch = cardIdWithProfile.match(/^([^.]+\.[^.]+\.[^.]*)/);
+            const cardId = cardIdMatch ? cardIdMatch[1] : cardIdWithProfile;
+            const pciMatch = cardIdWithProfile.match(/^(pci-[^.]+\.[^.]+\.[0-9]+)/);
+            if (pciMatch) {
+                return `${prefix}_card.${pciMatch[1]}`;
+            }
+            const usbMatch = cardIdWithProfile.match(/^(usb-[^.]+\.[^.]+\.[^.]+\-[0-9]+)/);
+            if (usbMatch) {
+                return `${prefix}_card.${usbMatch[1]}`;
+            }
+            const bluetoothMatch = cardIdWithProfile.match(/^([0-9A-F]{2}_[0-9A-F]{2}_[0-9A-F]{2}_[0-9A-F]{2}_[0-9A-F]{2}_[0-9A-F]{2})/i);
+            if (bluetoothMatch) {
+                return `${prefix}_card.${bluetoothMatch[1]}`;
+            }
+            const cardIdWithoutProfile = cardIdWithProfile.replace(/\.(analog-stereo|hdmi-stereo|hdmi-surround|stereo|mono|surround|a2dp|sco|off).*$/i, '');
+            if (cardIdWithoutProfile && cardIdWithoutProfile.length > 0) {
+                return `${prefix}_card.${cardIdWithoutProfile}`;
+            }
+        }
+        const altMatch = sinkId.match(/^([^_]+)_(?:output|input|sink|source)_(\d+)_(\d+)$/);
+        if (altMatch) {
+            const cardNumber = altMatch[2];
+            try {
+                const sinkInfo = (0, child_process_1.execSync)(PACTL_COMMANDS.GET_SINK_INFO(sinkId), {
+                    timeout: PACTL_TIMEOUT,
+                    stdio: 'pipe',
+                    env,
+                }).toString();
+                const cardNumMatch = sinkInfo.match(/alsa\.card\s*=\s*"(\d+)"/);
+                if (cardNumMatch) {
+                    const actualCardNumber = cardNumMatch[1];
+                    const cardsOutput = (0, child_process_1.execSync)(PACTL_COMMANDS.LIST_CARDS_SHORT(), {
+                        timeout: PACTL_TIMEOUT,
+                        stdio: 'pipe',
+                        env,
+                    }).toString();
+                    const cardLine = cardsOutput.split('\n').find(line => {
+                        const parts = line.split('\t');
+                        return (parts[0] === actualCardNumber || line.match(new RegExp(`^${actualCardNumber}\\s+`)));
+                    });
+                    if (cardLine) {
+                        const parts = cardLine.split('\t');
+                        if (parts.length >= 2) {
+                            const cardName = parts[1].trim();
+                            if (cardName && cardName.includes('_card.')) {
+                                return cardName;
+                            }
+                        }
+                        const cardNameMatch = cardLine.match(/([a-z0-9_]+_card\.[^\s\t]+)/i);
+                        if (cardNameMatch) {
+                            return cardNameMatch[1];
+                        }
+                    }
+                }
+            }
+            catch (error) {
+                logger.warn(`getCardNameFromSink(): Sink info lookup failed for sink ${sinkId}, card number ${cardNumber}, continuing with fallback:`, error);
+            }
+            try {
+                const cardsOutput = (0, child_process_1.execSync)(PACTL_COMMANDS.LIST_CARDS_SHORT(), {
+                    timeout: PACTL_TIMEOUT,
+                    stdio: 'pipe',
+                    env,
+                }).toString();
+                const cardLine = cardsOutput.split('\n').find(line => {
+                    const parts = line.split('\t');
+                    return parts[0] === cardNumber || line.match(new RegExp(`^${cardNumber}\\s+`));
+                });
+                if (cardLine) {
+                    const parts = cardLine.split('\t');
+                    if (parts.length >= 2) {
+                        const cardName = parts[1].trim();
+                        if (cardName && cardName.includes('_card.')) {
+                            return cardName;
+                        }
+                    }
+                    const cardNameMatch = cardLine.match(/([a-z0-9_]+_card\.[^\s\t]+)/i);
+                    if (cardNameMatch) {
+                        return cardNameMatch[1];
+                    }
+                }
+            }
+            catch (error) {
+                logger.warn(`getCardNameFromSink(): Card lookup failed for sink ${sinkId}, card number ${cardNumber}:`, error);
+            }
+        }
+        return null;
+    }
+    catch (error) {
+        logger.warn(`getCardNameFromSink(): Failed to get card name for sink ${sinkId}:`, error);
+        return null;
+    }
+}
+function isAnalogSink(sinkId) {
+    try {
+        const env = getPulseAudioEnv();
+        const sinkInfo = (0, child_process_1.execSync)(PACTL_COMMANDS.GET_SINK_INFO(sinkId), {
+            timeout: PACTL_TIMEOUT,
+            stdio: 'pipe',
+            env,
+        }).toString();
+        const descriptionMatch = sinkInfo.match(/Description:\s*([^\n]+)/);
+        const description = descriptionMatch ? descriptionMatch[1].toLowerCase() : '';
+        const hasAnalogInDescription = description.includes('analog') ||
+            description.includes('headphone') ||
+            description.includes('speaker') ||
+            description.includes('built-in') ||
+            description.includes('stereo');
+        const hasAnalogInId = sinkId.toLowerCase().includes('analog') ||
+            sinkId.toLowerCase().includes('headphone') ||
+            sinkId.toLowerCase().includes('speaker');
+        const hasAnalogInProperties = sinkInfo.includes('alsa.id = "Analog') ||
+            sinkInfo.includes('alsa.name = "Analog') ||
+            !!sinkInfo.match(/alsa\.id\s*=\s*"Analog/i);
+        const isNotHdmi = !isHdmiSink(sinkId);
+        return hasAnalogInDescription || hasAnalogInId || hasAnalogInProperties || isNotHdmi;
+    }
+    catch (error) {
+        logger.warn(`isAnalogSink(): Failed to check if sink ${sinkId} is analog:`, error);
+        return !sinkId.toLowerCase().includes('hdmi');
+    }
+}
+function getAvailableOutputProfiles(cardInfo) {
+    const profiles = [];
+    const profilesSection = cardInfo.match(/Profiles?:([\s\S]*?)(?=\s+\w+:|\s*$)/);
+    if (profilesSection) {
+        const profileLines = profilesSection[1].split('\n');
+        for (const line of profileLines) {
+            const match = line.match(/^\s+(output:[^:]+):/);
+            if (match && match[1]) {
+                const profileName = match[1];
+                if (!profiles.includes(profileName)) {
+                    profiles.push(profileName);
+                }
+            }
+            else {
+                const simpleMatch = line.match(/^\s+(output:[^\s]+)\s/);
+                if (simpleMatch && simpleMatch[1] && !profiles.includes(simpleMatch[1])) {
+                    profiles.push(simpleMatch[1]);
+                }
+            }
+        }
+    }
+    const allLines = cardInfo.split('\n');
+    for (const line of allLines) {
+        const match = line.match(/^\s+(output:[^:]+):/);
+        if (match && match[1]) {
+            const profileName = match[1];
+            if (!profiles.includes(profileName)) {
+                profiles.push(profileName);
+            }
+        }
+        else {
+            const simpleMatch = line.match(/^\s+(output:[^\s]+)\s/);
+            if (simpleMatch && simpleMatch[1] && !profiles.includes(simpleMatch[1])) {
+                profiles.push(simpleMatch[1]);
+            }
+        }
+    }
+    return profiles;
+}
+function getAnalogProfileForCard(cardName) {
+    try {
+        const env = getPulseAudioEnv();
+        const cardInfo = (0, child_process_1.execSync)(PACTL_COMMANDS.GET_CARD_INFO(cardName), {
+            timeout: PACTL_TIMEOUT,
+            stdio: 'pipe',
+            env,
+        }).toString();
+        const profilesSection = cardInfo.match(/Profiles?:([\s\S]*?)(?=\s+\w+:|\s*$)/);
+        if (profilesSection) {
+            const stereoMatch = profilesSection[1].match(/^\s+(output:analog-stereo[^\s]*)\s/);
+            if (stereoMatch) {
+                return stereoMatch[1].trim();
+            }
+            const analogMatch = profilesSection[1].match(/^\s+(output:analog[^\s]+)\s/);
+            if (analogMatch) {
+                return analogMatch[1].trim();
+            }
+        }
+        const analogProfileMatch = cardInfo.match(/^\s+(output:analog-stereo[^\s]*)$/m);
+        if (analogProfileMatch) {
+            return analogProfileMatch[1].trim();
+        }
+        return 'output:analog-stereo';
+    }
+    catch (error) {
+        logger.warn(`getAnalogProfileForCard(): Failed to get analog profile for card ${cardName}:`, error);
+        return 'output:analog-stereo';
+    }
+}
+function getHdmiProfileForCard(cardName) {
+    try {
+        const env = getPulseAudioEnv();
+        const cardInfo = (0, child_process_1.execSync)(PACTL_COMMANDS.GET_CARD_INFO(cardName), {
+            timeout: PACTL_TIMEOUT,
+            stdio: 'pipe',
+            env,
+        }).toString();
+        const profilesSection = cardInfo.match(/Profiles?:([\s\S]*?)(?=\s+\w+:|\s*$)/);
+        if (profilesSection) {
+            const stereoMatch = profilesSection[1].match(/^\s+(output:hdmi-stereo[^\s]*)\s/);
+            if (stereoMatch) {
+                return stereoMatch[1].trim();
+            }
+            const hdmiMatch = profilesSection[1].match(/^\s+(output:hdmi[^\s]+)\s/);
+            if (hdmiMatch) {
+                return hdmiMatch[1].trim();
+            }
+        }
+        const hdmiProfileMatch = cardInfo.match(/^\s+(output:hdmi-stereo[^\s]*)$/m);
+        if (hdmiProfileMatch) {
+            return hdmiProfileMatch[1].trim();
+        }
+        const anyHdmiMatch = cardInfo.match(/^\s+(output:hdmi[^\s]+)$/m);
+        if (anyHdmiMatch) {
+            return anyHdmiMatch[1].trim();
+        }
+        return 'output:hdmi-stereo';
+    }
+    catch (error) {
+        logger.warn(`getHdmiProfileForCard(): Failed to get HDMI profile for card ${cardName}:`, error);
+        return 'output:hdmi-stereo';
+    }
+}
+function isHdmiSink(sinkId) {
+    try {
+        const env = getPulseAudioEnv();
+        const sinkInfo = (0, child_process_1.execSync)(PACTL_COMMANDS.GET_SINK_INFO(sinkId), {
+            timeout: PACTL_TIMEOUT,
+            stdio: 'pipe',
+            env,
+        }).toString();
+        const hasHdmiIndicator = sinkInfo.includes('device.product.name = "HDMI') ||
+            sinkInfo.includes('alsa.id = "HDMI') ||
+            !!sinkInfo.match(/device\.product\.name\s*=\s*"[^"]*HDMI[^"]*"/i) ||
+            !!sinkInfo.match(/alsa\.id\s*=\s*"HDMI/i);
+        const descriptionMatch = sinkInfo.match(/Description:\s*([^\n]+)/);
+        const description = descriptionMatch ? descriptionMatch[1].toLowerCase() : '';
+        const hasHdmiInDescription = description.includes('hdmi') ||
+            description.includes('displayport') ||
+            description.includes('display') ||
+            description.includes('ultrafine') ||
+            description.includes('monitor');
+        const hasHdmiInId = sinkId.toLowerCase().includes('hdmi');
+        return hasHdmiIndicator || hasHdmiInDescription || hasHdmiInId;
+    }
+    catch (error) {
+        logger.warn(`isHdmiSink(): Failed to check if sink ${sinkId} is HDMI:`, error);
+        return sinkId.toLowerCase().includes('hdmi');
+    }
+}
+async function applyAudioOutputControlAndReport(audioOutputControl, twinId, hubDevice, context = 'applyAudioOutputControlAndReport') {
+    try {
+        logger.info(`${context}: Applying audio output control settings:`, audioOutputControl);
+        const success = await applyAudioOutputControl(audioOutputControl);
+        if (success) {
+            logger.info(`${context}: Audio output control settings applied successfully`);
+            logger.info(`${context}: Re-reporting system information with updated audio state...`);
+            try {
+                const deviceInfo = await (0, sysinfo_1.default)();
+                await hubDevice.reportDeviceTwinProperties(twinId, deviceInfo);
+                logger.info(`${context}: System information re-reported successfully`);
+            }
+            catch (reportError) {
+                logger.error(`${context}: Failed to re-report system information:`, reportError);
+            }
+            return true;
+        }
+        else {
+            logger.error(`${context}: Failed to apply audio output control settings`);
+            return false;
+        }
+    }
+    catch (error) {
+        logger.error(`${context}: Failed to apply audio output control:`, error);
+        return false;
+    }
+}
+async function applyAudioInputControlAndReport(audioInputControl, twinId, hubDevice, context = 'applyAudioInputControlAndReport') {
+    try {
+        logger.info(`${context}: Applying audio input control settings:`, audioInputControl);
+        const success = await applyAudioInputControl(audioInputControl);
+        if (success) {
+            logger.info(`${context}: Audio input control settings applied successfully`);
+            logger.info(`${context}: Re-reporting system information with updated audio state...`);
+            try {
+                const deviceInfo = await (0, sysinfo_1.default)();
+                await hubDevice.reportDeviceTwinProperties(twinId, deviceInfo);
+                logger.info(`${context}: System information re-reported successfully`);
+            }
+            catch (reportError) {
+                logger.error(`${context}: Failed to re-report system information:`, reportError);
+            }
+            return true;
+        }
+        else {
+            logger.error(`${context}: Failed to apply audio input control settings`);
+            return false;
+        }
+    }
+    catch (error) {
+        logger.error(`${context}: Failed to apply audio input control:`, error);
+        return false;
+    }
+}
+async function applyAudioOutputControl(audioOutputControl) {
+    const { identifier, volume, muted, activePort } = audioOutputControl;
+    if (!identifier) {
+        logger.error('applyAudioOutputControl(): identifier is required');
+        return false;
+    }
+    try {
+        const env = getPulseAudioEnv();
+        let sinkId = identifier;
+        let sinkExists = false;
+        try {
+            const sinkCheck = (0, child_process_1.execSync)(PACTL_COMMANDS.CHECK_SINK_EXISTS(identifier), {
+                timeout: PACTL_TIMEOUT,
+                stdio: 'pipe',
+                env,
+            }).toString();
+            sinkExists = sinkCheck.trim().length > 0;
+        }
+        catch (error) {
+            logger.warn(`applyAudioOutputControl(): Failed to check if sink exists for identifier ${identifier}:`, error);
+        }
+        if (sinkExists) {
+            const isSimpleFormat = identifier.match(/^[^_]+_(output|input|sink|source)_\d+_\d+$/);
+            if (isSimpleFormat) {
+                let sinkInfo = '';
+                try {
+                    sinkInfo = (0, child_process_1.execSync)(PACTL_COMMANDS.GET_SINK_INFO(identifier), {
+                        timeout: PACTL_TIMEOUT,
+                        stdio: 'pipe',
+                        env,
+                    }).toString();
+                }
+                catch (error) {
+                    logger.warn(`applyAudioOutputControl(): Could not get sink info for identifier ${identifier}:`, error);
+                }
+                const descriptionMatch = sinkInfo.match(/Description:\s*([^\n]+)/);
+                const description = descriptionMatch ? descriptionMatch[1].toLowerCase() : '';
+                const alsaIdMatch = sinkInfo.match(/alsa\.id\s*=\s*"([^"]+)"/);
+                const alsaId = alsaIdMatch ? alsaIdMatch[1].toLowerCase() : '';
+                let isHdmiSink = false;
+                let isAnalogSink = false;
+                if (alsaId.includes('hdmi')) {
+                    isHdmiSink = true;
+                }
+                else if (alsaId.includes('analog') || alsaId.includes('alc269vb')) {
+                    isAnalogSink = true;
+                }
+                else if (description.includes('ultrafine') ||
+                    description.includes('hdmi') ||
+                    description.includes('display')) {
+                    isHdmiSink = true;
+                }
+                else if (description.includes('analog') ||
+                    description.includes('headphone') ||
+                    description.includes('speaker') ||
+                    description.includes('alc269vb')) {
+                    isAnalogSink = true;
+                }
+                else if (identifier.toLowerCase().includes('hdmi')) {
+                    isHdmiSink = true;
+                }
+                else if (identifier.toLowerCase().includes('analog')) {
+                    isAnalogSink = true;
+                }
+                const cardName = getCardNameFromSink(identifier);
+                if (!cardName) {
+                    logger.warn(`applyAudioOutputControl(): Could not get card name for ${identifier}, skipping profile check`);
+                }
+                else {
+                    logger.info(`applyAudioOutputControl(): Got card name: ${cardName}`);
+                    try {
+                        const cardInfo = (0, child_process_1.execSync)(PACTL_COMMANDS.GET_CARD_INFO(cardName), {
+                            timeout: PACTL_TIMEOUT,
+                            stdio: 'pipe',
+                            env,
+                        }).toString();
+                        let activeProfile = null;
+                        const activeProfileLineMatch = cardInfo.match(/Active Profile:\s*(output:[^\s\n]+)/i);
+                        if (activeProfileLineMatch) {
+                            activeProfile = activeProfileLineMatch[1];
+                        }
+                        else {
+                            const activeProfileMatch = cardInfo.match(/^\s+(output:[^:]+):[^\n]*\*[^\n]*$/m);
+                            if (activeProfileMatch) {
+                                activeProfile = activeProfileMatch[1];
+                            }
+                            else {
+                                const activeProfileMatch2 = cardInfo.match(/\s+(output:[^:]+):[^\n]*\*[^\n]*/);
+                                if (activeProfileMatch2) {
+                                    activeProfile = activeProfileMatch2[1];
+                                }
+                                else {
+                                    const availableProfiles = getAvailableOutputProfiles(cardInfo);
+                                    if (availableProfiles.length === 1) {
+                                        activeProfile = availableProfiles[0];
+                                    }
+                                }
+                            }
+                        }
+                        logger.info(`applyAudioOutputControl(): Current active profile: ${activeProfile}`);
+                        let requiredProfile = null;
+                        if (isHdmiSink && !isAnalogSink) {
+                            requiredProfile = getHdmiProfileForCard(cardName);
+                            logger.info(`applyAudioOutputControl(): HDMI sink detected, required profile: ${requiredProfile}`);
+                        }
+                        else if (isAnalogSink && !isHdmiSink) {
+                            requiredProfile = getAnalogProfileForCard(cardName);
+                            logger.info(`applyAudioOutputControl(): Analog sink detected, required profile: ${requiredProfile}`);
+                        }
+                        else {
+                            logger.warn(`applyAudioOutputControl(): Ambiguous sink type (HDMI: ${isHdmiSink}, Analog: ${isAnalogSink}), cannot determine required profile`);
+                        }
+                        if (requiredProfile && activeProfile !== requiredProfile) {
+                            logger.info(`applyAudioOutputControl(): Profile mismatch! Active: ${activeProfile}, Required: ${requiredProfile}. Switching profile...`);
+                            (0, child_process_1.execSync)(PACTL_COMMANDS.SET_CARD_PROFILE(cardName, requiredProfile), {
+                                timeout: PACTL_TIMEOUT,
+                                stdio: 'pipe',
+                                env,
+                            });
+                            await new Promise(resolve => setTimeout(resolve, 500));
+                            const sinksOutput = (0, child_process_1.execSync)(PACTL_COMMANDS.LIST_SINKS_SHORT(), {
+                                timeout: PACTL_TIMEOUT,
+                                stdio: 'pipe',
+                                env,
+                            }).toString();
+                            const cardId = cardName.replace(/^[^.]*\./, '');
+                            let foundSink = false;
+                            const deviceMatch = identifier.match(/[^_]+_(\d+)_(\d+)$/);
+                            if (deviceMatch) {
+                                const deviceNum = deviceMatch[2];
+                                let sinkLines = sinksOutput.split('\n').filter(line => line.includes(cardId));
+                                if (isHdmiSink) {
+                                    sinkLines = sinkLines.filter(line => line.toLowerCase().includes('hdmi'));
+                                }
+                                else if (isAnalogSink) {
+                                    sinkLines = sinkLines.filter(line => line.toLowerCase().includes('analog') || line.toLowerCase().includes('stereo'));
+                                }
+                                let sinkLine = sinkLines.find(line => line.includes(`device=${deviceNum}`) ||
+                                    line.includes(`_${deviceMatch[1]}_${deviceNum}`));
+                                if (!sinkLine && sinkLines.length > 0) {
+                                    sinkLine = sinkLines[0];
+                                }
+                                if (sinkLine) {
+                                    sinkId = sinkLine.split('\t')[1];
+                                    logger.info(`applyAudioOutputControl(): Found sink ${sinkId} after profile switch (by device number)`);
+                                    foundSink = true;
+                                }
+                            }
+                            if (!foundSink) {
+                                let sinkLines = sinksOutput.split('\n').filter(line => line.includes(cardId));
+                                if (isHdmiSink) {
+                                    sinkLines = sinkLines.filter(line => line.toLowerCase().includes('hdmi'));
+                                }
+                                else if (isAnalogSink) {
+                                    sinkLines = sinkLines.filter(line => line.toLowerCase().includes('analog') || line.toLowerCase().includes('stereo'));
+                                }
+                                if (sinkLines.length > 0) {
+                                    sinkId = sinkLines[0].split('\t')[1];
+                                    logger.info(`applyAudioOutputControl(): Found sink ${sinkId} after profile switch (by card and profile type)`);
+                                    foundSink = true;
+                                }
+                            }
+                            if (!foundSink) {
+                                try {
+                                    const checkSink = (0, child_process_1.execSync)(PACTL_COMMANDS.CHECK_SINK_EXISTS(identifier), {
+                                        timeout: PACTL_TIMEOUT,
+                                        stdio: 'pipe',
+                                        env,
+                                    }).toString();
+                                    if (checkSink.trim().length > 0) {
+                                        sinkId = identifier;
+                                        logger.info(`applyAudioOutputControl(): Original sink ${sinkId} still exists after profile switch`);
+                                        foundSink = true;
+                                    }
+                                }
+                                catch (error) {
+                                    logger.warn(`applyAudioOutputControl(): Failed to check if original sink exists for identifier ${identifier}:`, error);
+                                }
+                            }
+                            if (!foundSink) {
+                                logger.warn(`applyAudioOutputControl(): Could not find sink after profile switch, using original identifier`);
+                            }
+                        }
+                        else if (activeProfile && requiredProfile) {
+                            logger.info(`applyAudioOutputControl(): Profile is correct (${activeProfile}), using sink directly`);
+                        }
+                        else {
+                            logger.warn(`applyAudioOutputControl(): Could not determine active or required profile, using sink as-is`);
+                        }
+                    }
+                    catch (error) {
+                        logger.warn(`applyAudioOutputControl(): Could not check/switch profile: ${error}, using sink as-is`);
+                    }
+                }
+            }
+            if (!sinkId || sinkId === identifier) {
+                sinkId = identifier;
+            }
+        }
+        else {
+            const flatFormatMatch = identifier.match(/^([^_]+)_(output|input|sink|source)\.([^.]+(?:\.[^.]+)*)\.(.+)$/);
+            if (flatFormatMatch) {
+                const prefix = flatFormatMatch[1];
+                const cardId = flatFormatMatch[3];
+                const profileSuffix = flatFormatMatch[4];
+                const cardName = `${prefix}_card.${cardId}`;
+                const profile = `output:${profileSuffix}`;
+                try {
+                    (0, child_process_1.execSync)(PACTL_COMMANDS.SET_CARD_PROFILE(cardName, profile), {
+                        timeout: PACTL_TIMEOUT,
+                        stdio: 'pipe',
+                        env,
+                    });
+                    await new Promise(resolve => setTimeout(resolve, 500));
+                    const sinksOutput = (0, child_process_1.execSync)(PACTL_COMMANDS.LIST_SINKS_SHORT(), {
+                        timeout: PACTL_TIMEOUT,
+                        stdio: 'pipe',
+                        env,
+                    }).toString();
+                    const sinkLine = sinksOutput
+                        .split('\n')
+                        .find(line => line.includes(cardId) && line.includes(profileSuffix));
+                    if (sinkLine) {
+                        sinkId = sinkLine.split('\t')[1];
+                    }
+                    else {
+                        logger.error(`applyAudioOutputControl(): Failed to find sink after setting profile`);
+                        return false;
+                    }
+                }
+                catch (error) {
+                    logger.error(`applyAudioOutputControl(): Failed to set profile: ${error}`);
+                    return false;
+                }
+            }
+            else {
+                const cardName = getCardNameFromSink(identifier);
+                if (!cardName) {
+                    logger.error(`applyAudioOutputControl(): Could not determine card name for ${identifier}`);
+                    return false;
+                }
+                let sinkInfo = '';
+                let sinkExistsWithDifferentProfile = false;
+                try {
+                    sinkInfo = (0, child_process_1.execSync)(PACTL_COMMANDS.GET_SINK_INFO(identifier), {
+                        timeout: PACTL_TIMEOUT,
+                        stdio: 'pipe',
+                        env,
+                    }).toString();
+                    sinkExistsWithDifferentProfile = sinkInfo.length > 0;
+                }
+                catch (error) {
+                    logger.warn(`applyAudioOutputControl(): Failed to check if sink exists with different profile for identifier ${identifier}:`, error);
+                }
+                let isHdmi = false;
+                let isAnalog = false;
+                if (identifier.toLowerCase().includes('hdmi')) {
+                    isHdmi = true;
+                }
+                else if (identifier.toLowerCase().includes('analog')) {
+                    isAnalog = true;
+                }
+                else if (sinkExistsWithDifferentProfile) {
+                    const hasHdmiInInfo = sinkInfo.includes('HDMI') ||
+                        sinkInfo.includes('alsa.id = "HDMI') ||
+                        sinkInfo.toLowerCase().includes('ultrafine') ||
+                        sinkInfo.toLowerCase().includes('display');
+                    const hasAnalogInInfo = sinkInfo.includes('analog') ||
+                        sinkInfo.toLowerCase().includes('headphone') ||
+                        sinkInfo.toLowerCase().includes('speaker');
+                    isHdmi = hasHdmiInInfo;
+                    isAnalog = hasAnalogInInfo;
+                }
+                if (!isHdmi && !isAnalog) {
+                    try {
+                        const cardInfo = (0, child_process_1.execSync)(PACTL_COMMANDS.GET_CARD_INFO(cardName), {
+                            timeout: PACTL_TIMEOUT,
+                            stdio: 'pipe',
+                            env,
+                        }).toString();
+                        const sinksOutput = (0, child_process_1.execSync)(PACTL_COMMANDS.LIST_SINKS_SHORT(), {
+                            timeout: PACTL_TIMEOUT,
+                            stdio: 'pipe',
+                            env,
+                        }).toString();
+                        const cardId = cardName.replace(/^[^.]*\./, '');
+                        const deviceMatch = identifier.match(/[^_]+_(\d+)_(\d+)$/);
+                        if (deviceMatch) {
+                            const deviceNum = deviceMatch[2];
+                            const hdmiSinkLine = sinksOutput
+                                .split('\n')
+                                .find(line => line.includes(cardId) &&
+                                (line.includes(`device=${deviceNum}`) ||
+                                    line.includes(`_${deviceMatch[1]}_${deviceNum}`)) &&
+                                line.toLowerCase().includes('hdmi'));
+                            const analogSinkLine = sinksOutput
+                                .split('\n')
+                                .find(line => line.includes(cardId) &&
+                                (line.includes(`device=${deviceNum}`) ||
+                                    line.includes(`_${deviceMatch[1]}_${deviceNum}`)) &&
+                                (line.toLowerCase().includes('analog') || line.toLowerCase().includes('stereo')));
+                            if (hdmiSinkLine && !analogSinkLine) {
+                                isHdmi = true;
+                            }
+                            else if (analogSinkLine && !hdmiSinkLine) {
+                                isAnalog = true;
+                            }
+                            else {
+                                const availableProfiles = getAvailableOutputProfiles(cardInfo);
+                                const hasHdmiProfile = availableProfiles.some(p => p.toLowerCase().includes('hdmi'));
+                                const hasAnalogProfile = availableProfiles.some(p => p.toLowerCase().includes('analog') || p.toLowerCase().includes('stereo'));
+                                if (hasHdmiProfile && hasAnalogProfile) {
+                                    const activeProfileMatch = cardInfo.match(/^\s+(output:[^:]+):[^\n]*\*[^\n]*$/m);
+                                    if (activeProfileMatch) {
+                                        const activeProfile = activeProfileMatch[1];
+                                        isHdmi = activeProfile.toLowerCase().includes('hdmi');
+                                        isAnalog = !isHdmi && activeProfile.toLowerCase().includes('analog');
+                                    }
+                                    else {
+                                        isAnalog = true;
+                                    }
+                                }
+                                else if (hasHdmiProfile) {
+                                    isHdmi = true;
+                                }
+                                else if (hasAnalogProfile) {
+                                    isAnalog = true;
+                                }
+                            }
+                        }
+                    }
+                    catch (error) {
+                        logger.warn(`applyAudioOutputControl(): Failed to detect profile type: ${error}`);
+                        isAnalog = true;
+                    }
+                }
+                let profile = null;
+                if (isHdmi && !isAnalog) {
+                    profile = getHdmiProfileForCard(cardName);
+                }
+                else if (isAnalog && !isHdmi) {
+                    profile = getAnalogProfileForCard(cardName);
+                }
+                else {
+                    logger.warn(`applyAudioOutputControl(): Could not determine profile type (neither HDMI nor Analog detected)`);
+                }
+                if (profile) {
+                    try {
+                        logger.info(`applyAudioOutputControl(): Setting card profile ${cardName} to ${profile} (${isHdmi ? 'HDMI' : 'Analog'})`);
+                        (0, child_process_1.execSync)(PACTL_COMMANDS.SET_CARD_PROFILE(cardName, profile), {
+                            timeout: PACTL_TIMEOUT,
+                            stdio: 'pipe',
+                            env,
+                        });
+                        await new Promise(resolve => setTimeout(resolve, 500));
+                        const sinksOutput = (0, child_process_1.execSync)(PACTL_COMMANDS.LIST_SINKS_SHORT(), {
+                            timeout: PACTL_TIMEOUT,
+                            stdio: 'pipe',
+                            env,
+                        }).toString();
+                        const deviceMatch = identifier.match(/[^_]+_(\d+)_(\d+)$/);
+                        if (deviceMatch) {
+                            const deviceNum = deviceMatch[2];
+                            const cardId = cardName.replace(/^[^.]*\./, '');
+                            let sinkLines = sinksOutput.split('\n').filter(line => line.includes(cardId));
+                            if (isHdmi) {
+                                sinkLines = sinkLines.filter(line => line.toLowerCase().includes('hdmi'));
+                            }
+                            else if (isAnalog) {
+                                sinkLines = sinkLines.filter(line => line.toLowerCase().includes('analog') || line.toLowerCase().includes('stereo'));
+                            }
+                            const sinkLine = sinkLines.find(line => line.includes(`device=${deviceNum}`) ||
+                                line.includes(`_${deviceMatch[1]}_${deviceNum}`));
+                            if (sinkLine) {
+                                sinkId = sinkLine.split('\t')[1];
+                            }
+                            else {
+                                if (sinkLines.length > 0) {
+                                    sinkId = sinkLines[0].split('\t')[1];
+                                }
+                                else {
+                                    logger.error(`applyAudioOutputControl(): Failed to find sink after setting profile`);
+                                    return false;
+                                }
+                            }
+                        }
+                        else {
+                            sinkId = identifier;
+                        }
+                    }
+                    catch (error) {
+                        logger.error(`applyAudioOutputControl(): Failed to set profile: ${error}`);
+                        return false;
+                    }
+                }
+                else {
+                    logger.error(`applyAudioOutputControl(): Could not determine profile for ${identifier}`);
+                    return false;
+                }
+            }
+        }
+        try {
+            (0, child_process_1.execSync)(PACTL_COMMANDS.SET_DEFAULT_SINK(sinkId), {
+                timeout: PACTL_TIMEOUT,
+                stdio: 'pipe',
+                env,
+            });
+        }
+        catch (error) {
+            logger.error(`applyAudioOutputControl(): Failed to set default sink: ${error}`);
+            return false;
+        }
+        try {
+            (0, child_process_1.execSync)(PACTL_COMMANDS.SUSPEND_SINK(sinkId, false), {
+                timeout: PACTL_TIMEOUT,
+                stdio: 'pipe',
+                env,
+            });
+        }
+        catch (error) {
+            logger.error(`applyAudioOutputControl(): Failed to unsuspend sink: ${error}`);
+            return false;
+        }
+        try {
+            const sinkInputsOutput = (0, child_process_1.execSync)(PACTL_COMMANDS.LIST_SINK_INPUTS(), {
+                timeout: PACTL_TIMEOUT,
+                stdio: 'pipe',
+                env,
+            }).toString();
+            const sinkInputs = sinkInputsOutput.split('\n').filter(line => line.trim());
+            sinkInputs.forEach(line => {
+                const inputId = line.split('\t')[0];
+                if (inputId && !isNaN(Number(inputId))) {
+                    try {
+                        (0, child_process_1.execSync)(PACTL_COMMANDS.MOVE_SINK_INPUT(inputId, sinkId), {
+                            timeout: PACTL_TIMEOUT,
+                            stdio: 'pipe',
+                            env,
+                        });
+                        (0, child_process_1.execSync)(PACTL_COMMANDS.CORK_SINK_INPUT(inputId, true), {
+                            timeout: PACTL_TIMEOUT,
+                            stdio: 'pipe',
+                            env,
+                        });
+                    }
+                    catch (error) {
+                        logger.warn(`applyAudioOutputControl(): Failed to move/uncork sink-input ${inputId}:`, error);
+                    }
+                }
+            });
+        }
+        catch (error) {
+            logger.warn(`applyAudioOutputControl(): Failed to list/move sink inputs:`, error);
+        }
+        if (volume !== undefined) {
+            const volumePercent = Math.max(0, Math.min(100, volume));
+            try {
+                (0, child_process_1.execSync)(PACTL_COMMANDS.SET_SINK_VOLUME(sinkId, volumePercent), {
+                    timeout: PACTL_TIMEOUT,
+                    stdio: 'pipe',
+                    env,
+                });
+            }
+            catch (error) {
+                logger.error(`applyAudioOutputControl(): Failed to set volume: ${error}`);
+                return false;
+            }
+        }
+        if (muted !== undefined) {
+            try {
+                (0, child_process_1.execSync)(PACTL_COMMANDS.SET_SINK_MUTE(sinkId, muted ? '1' : '0'), {
+                    timeout: PACTL_TIMEOUT,
+                    stdio: 'pipe',
+                    env,
+                });
+            }
+            catch (error) {
+                logger.error(`applyAudioOutputControl(): Failed to set mute: ${error}`);
+                return false;
+            }
+        }
+        if (activePort) {
+            try {
+                (0, child_process_1.execSync)(PACTL_COMMANDS.SET_SINK_PORT(sinkId, activePort), {
+                    timeout: PACTL_TIMEOUT,
+                    stdio: 'pipe',
+                    env,
+                });
+            }
+            catch (error) {
+                logger.warn(`applyAudioOutputControl(): Failed to set sink port ${activePort} for sink ${sinkId}:`, error);
+            }
+        }
+        return true;
+    }
+    catch (error) {
+        logger.error('applyAudioOutputControl(): Failed:', error);
+        return false;
+    }
+}
+async function applyAudioInputControl(audioInputControl) {
+    const { identifier, volume, muted, activePort } = audioInputControl;
+    if (!identifier) {
+        logger.error('applyAudioInputControl(): identifier is required');
+        return false;
+    }
+    try {
+        logger.info(`applyAudioInputControl(): Applying settings to source "${identifier}"`, {
+            volume,
+            muted,
+            activePort,
+        });
+        if (activePort) {
+            logger.info(`applyAudioInputControl(): Setting active port to "${activePort}"`);
+            const env = getPulseAudioEnv();
+            (0, child_process_1.execSync)(PACTL_COMMANDS.SET_SOURCE_PORT(identifier, activePort), {
+                timeout: PACTL_TIMEOUT,
+                stdio: 'pipe',
+                env,
+            });
+            logger.info(` Active port set to "${activePort}"`);
+        }
+        logger.info(`applyAudioInputControl(): Setting as default source`);
+        const env = getPulseAudioEnv();
+        (0, child_process_1.execSync)(PACTL_COMMANDS.SET_DEFAULT_SOURCE(identifier), {
+            timeout: PACTL_TIMEOUT,
+            stdio: 'pipe',
+            env,
+        });
+        logger.info(` Source set as default`);
+        if (volume !== undefined) {
+            const volumePercent = Math.max(0, Math.min(100, volume));
+            logger.info(`applyAudioInputControl(): Setting volume to ${volumePercent}%`);
+            const env = getPulseAudioEnv();
+            (0, child_process_1.execSync)(PACTL_COMMANDS.SET_SOURCE_VOLUME(identifier, volumePercent), {
+                timeout: PACTL_TIMEOUT,
+                stdio: 'pipe',
+                env,
+            });
+            logger.info(` Volume set to ${volumePercent}%`);
+        }
+        if (muted !== undefined) {
+            const muteValue = muted ? '1' : '0';
+            logger.info(`applyAudioInputControl(): Setting mute to ${muted}`);
+            const env = getPulseAudioEnv();
+            (0, child_process_1.execSync)(PACTL_COMMANDS.SET_SOURCE_MUTE(identifier, muteValue), {
+                timeout: PACTL_TIMEOUT,
+                stdio: 'pipe',
+                env,
+            });
+            logger.info(` Mute set to ${muted}`);
+        }
+        logger.info(' Audio input control settings applied successfully');
+        return true;
+    }
+    catch (error) {
+        logger.error('applyAudioInputControl(): Failed to apply audio input settings:', error instanceof Error ? error.message : String(error));
+        return false;
+    }
+}
+//# sourceMappingURL=audio-control.js.map