@phystack/hub-device 4.4.44 → 4.4.46

package/dist/sysinfo/node.js

@@ -3,8 +3,646 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.discoverPulseAudioSocket = discoverPulseAudioSocket;
+exports.getPulseAudioEnv = getPulseAudioEnv;
 exports.getSystemInformation = getSystemInformation;
 const systeminformation_1 = __importDefault(require("systeminformation"));
+const child_process_1 = require("child_process");
+const twin_types_1 = require("../types/twin.types");
+const PULSEAUDIO_COMMANDS = {
+    INFO: 'pactl info',
+    KILL: 'pulseaudio -k 2>/dev/null || true',
+    START_DAEMON: 'pulseaudio --daemonize --exit-idle-time=-1 --system=false',
+    WAIT: 'sleep 1',
+    LIST_MODULES: 'pactl list modules short',
+    LOAD_ALSA_MODULE: 'pactl load-module module-alsa-card',
+    LIST_SINKS: 'pactl list sinks',
+    LIST_SOURCES: 'pactl list sources',
+    LIST_CARDS: 'pactl list cards',
+    LIST_CARDS_SHORT: 'pactl list cards short',
+    LOAD_ALSA_SINK: (hwDevice, sinkName, description) => `pactl load-module module-alsa-sink device=${hwDevice} sink_name=${sinkName} sink_properties="device.description=${description}"`,
+    LOAD_ALSA_SOURCE: (hwDevice, sourceName, description) => `pactl load-module module-alsa-source device=${hwDevice} source_name=${sourceName} source_properties="device.description=${description}"`,
+};
+const ALSA_COMMANDS = {
+    APLAY_LIST: 'aplay -l 2>/dev/null',
+    ARECORD_LIST: 'arecord -l 2>/dev/null',
+};
+const PULSEAUDIO_TIMEOUTS = {
+    INFO_CHECK: 2000,
+    KILL: 2000,
+    START: 5000,
+    LIST_MODULES: 2000,
+    LOAD_MODULE: 3000,
+    LIST_DEVICES: 5000,
+};
+let pulseAudioServerPath;
+function parseAudioDevice(block, isInput) {
+    const lines = block.split('\n');
+    const device = {};
+    const ports = [];
+    let inPortsSection = false;
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        const trimmed = line.trim();
+        if (trimmed.startsWith('Name:')) {
+            device.identifier = trimmed.split('Name:')[1].trim();
+        }
+        else if (trimmed.startsWith('Description:')) {
+            device.displayName = trimmed.split('Description:')[1].trim();
+        }
+        else if (trimmed.includes('alsa.card =')) {
+            const cardMatch = trimmed.match(/alsa\.card\s*=\s*"(\d+)"/);
+            if (cardMatch) {
+                device.cardNumber = cardMatch[1];
+            }
+        }
+        else if (trimmed.includes('alsa.card_name =')) {
+            const cardNameMatch = trimmed.match(/alsa\.card_name\s*=\s*"([^"]+)"/);
+            if (cardNameMatch) {
+                device.cardNameRaw = cardNameMatch[1];
+            }
+        }
+        else if (trimmed.startsWith('Volume:')) {
+            const match = trimmed.match(/(\d+)%/);
+            if (match)
+                device.volume = parseInt(match[1], 10);
+        }
+        else if (trimmed.startsWith('Mute:')) {
+            device.muted = trimmed.toLowerCase().includes('yes');
+        }
+        else if (trimmed.startsWith('Active Port:')) {
+            device.activePort = trimmed.split('Active Port:')[1].trim();
+            console.log(`[Audio] Found active port: ${device.activePort}`);
+        }
+        else if (trimmed.startsWith('Ports:')) {
+            inPortsSection = true;
+            console.log(`[Audio] Entering ports section for device`);
+        }
+        else if (inPortsSection) {
+            if (trimmed.match(/^[A-Z][a-z]+:/) && !line.match(/^\s/)) {
+                inPortsSection = false;
+                console.log(`[Audio] Exiting ports section, found ${ports.length} ports`);
+            }
+            else if (trimmed.length > 0 && line.match(/^\s+\S/)) {
+                const portMatch = trimmed.match(/^([^:]+):\s*(.+?)(?:\s*\((.+)\))?$/);
+                if (portMatch) {
+                    const portName = portMatch[1].trim();
+                    const portDescription = portMatch[2].trim();
+                    const portDetails = portMatch[3];
+                    const port = {
+                        name: portName,
+                        description: portDescription,
+                    };
+                    if (portDetails) {
+                        const typeMatch = portDetails.match(/type:\s*([^,]+)/);
+                        const priorityMatch = portDetails.match(/priority:\s*(\d+)/);
+                        const availableMatch = portDetails.match(/available(?::\s*(yes|no))?|not available|availability unknown/i);
+                        if (typeMatch)
+                            port.type = typeMatch[1].trim();
+                        if (priorityMatch)
+                            port.priority = parseInt(priorityMatch[1], 10);
+                        if (availableMatch) {
+                            const availStr = availableMatch[0].toLowerCase();
+                            if (availStr.includes('availability unknown')) {
+                                port.availabilityStatus = twin_types_1.AvailabilityStatus.Unknown;
+                            }
+                            else if (availStr.includes('not available') || availStr.includes('available: no')) {
+                                port.availabilityStatus = twin_types_1.AvailabilityStatus.Unavailable;
+                            }
+                            else if (availStr.includes('available: yes')) {
+                                port.availabilityStatus = twin_types_1.AvailabilityStatus.Available;
+                            }
+                        }
+                    }
+                    console.log(`[Audio] Parsed port: ${portName} - ${portDescription}`);
+                    ports.push(port);
+                }
+            }
+        }
+        else if (trimmed.includes('device.product.name =')) {
+            const match = trimmed.match(/"([^"]+)"/);
+            if (match) {
+                device.productName = match[1];
+            }
+        }
+        else if (trimmed.includes('device.form_factor =')) {
+            const match = trimmed.match(/"([^"]+)"/);
+            if (match)
+                device.formFactor = match[1];
+        }
+        else if (trimmed.includes('device.bus =')) {
+            const match = trimmed.match(/"([^"]+)"/);
+            if (match)
+                device.bus = match[1];
+        }
+    }
+    if (isInput && device.identifier?.includes('.monitor')) {
+        return null;
+    }
+    if (!device.identifier)
+        return null;
+    if (ports.length > 0) {
+        device.availablePorts = ports;
+        console.log(`[Audio] Device ${device.identifier} has ${ports.length} ports, active: ${device.activePort}`);
+    }
+    else {
+        console.log(`[Audio] Device ${device.identifier} has NO ports detected`);
+    }
+    const availablePorts = ports.filter(p => p.availabilityStatus === twin_types_1.AvailabilityStatus.Available);
+    let deviceAvailable = availablePorts.length > 0;
+    if (ports.length === 0 && device.identifier) {
+        const stateMatch = block.match(/State:\s*(\w+)/i);
+        if (stateMatch) {
+            const state = stateMatch[1].toUpperCase();
+            if (state === 'RUNNING') {
+                deviceAvailable = true;
+            }
+            else {
+                try {
+                    const env = getPulseAudioEnv();
+                    const cardsOutput = (0, child_process_1.execSync)(PULSEAUDIO_COMMANDS.LIST_CARDS, {
+                        encoding: 'utf-8',
+                        timeout: 2000,
+                        stdio: 'pipe',
+                        env,
+                    });
+                    const deviceMatch = device.identifier.match(/[^_]+_(\d+)_(\d+)$/);
+                    if (deviceMatch) {
+                        const deviceNum = deviceMatch[2];
+                        const portMatch = cardsOutput.match(new RegExp(`hdmi-output-${deviceNum === '9' ? '2' : deviceNum === '8' ? '1' : deviceNum === '7' ? '1' : '0'}[^\\n]*available`, 'i'));
+                        if (portMatch && !portMatch[0].includes('not available')) {
+                            deviceAvailable = true;
+                        }
+                    }
+                }
+                catch (error) {
+                }
+            }
+        }
+    }
+    let cardMatch = device.identifier?.match(/^([^_]+)_(output|input|sink|source)\.([^.]+(?:\.[^.]+)*)\.(.+)$/);
+    if (cardMatch) {
+        const prefix = cardMatch[1];
+        const cardId = cardMatch[3];
+        device.cardName = `${prefix}_card.${cardId}`;
+    }
+    else {
+        cardMatch = device.identifier?.match(/^([^_]+)_(output|input|sink|source)\.(.+)$/);
+        if (cardMatch) {
+            const prefix = cardMatch[1];
+            const cardId = cardMatch[3];
+            device.cardName = `${prefix}_card.${cardId}`;
+        }
+        else {
+            const altMatch = device.identifier?.match(/^([^_]+)_(output|input|sink|source)_(\d+)_(\d+)$/);
+            if (altMatch) {
+                const cardNumber = altMatch[3];
+                try {
+                    const env = getPulseAudioEnv();
+                    const cardsOutput = (0, child_process_1.execSync)(PULSEAUDIO_COMMANDS.LIST_CARDS_SHORT, {
+                        encoding: 'utf-8',
+                        timeout: 2000,
+                        stdio: 'pipe',
+                        env,
+                    });
+                    const cardLine = cardsOutput.split('\n').find(line => line.includes(`card${cardNumber}`));
+                    if (cardLine) {
+                        const cardNameMatch = cardLine.match(/([^_\s]+_card\.[^\s]+)/);
+                        if (cardNameMatch) {
+                            device.cardName = cardNameMatch[1];
+                        }
+                    }
+                }
+                catch (error) {
+                }
+            }
+            else {
+                const cardNumber = device.cardNumber;
+                if (cardNumber !== undefined) {
+                    try {
+                        const env = getPulseAudioEnv();
+                        const cardsOutput = (0, child_process_1.execSync)(PULSEAUDIO_COMMANDS.LIST_CARDS_SHORT, {
+                            encoding: 'utf-8',
+                            timeout: 2000,
+                            stdio: 'pipe',
+                            env,
+                        });
+                        const cardLine = cardsOutput
+                            .split('\n')
+                            .find(line => line.includes(`card${cardNumber}`));
+                        if (cardLine) {
+                            const cardNameMatch = cardLine.match(/([^_\s]+_card\.[^\s]+)/);
+                            if (cardNameMatch) {
+                                device.cardName = cardNameMatch[1];
+                            }
+                        }
+                    }
+                    catch (error) {
+                    }
+                }
+            }
+        }
+    }
+    device.label = createDeviceLabel(device, ports, isInput, device.formFactor, device.bus, false, deviceAvailable, device.activePort);
+    const cleanDevice = {
+        identifier: device.identifier,
+        volume: device.volume,
+        muted: device.muted,
+        availablePorts: device.availablePorts,
+        label: device.label,
+    };
+    return cleanDevice;
+}
+function createDeviceLabel(device, ports, isInput, formFactor, bus, isDefault, available, activePort) {
+    const productName = device.productName;
+    let baseLabel = '';
+    const activePortInfo = activePort ? ports.find(p => p.name === activePort) : undefined;
+    if (productName) {
+        baseLabel = `${productName} (${isInput ? 'Microphone' : 'Speaker'})`;
+    }
+    else if (activePortInfo && activePortInfo.description) {
+        const portDesc = activePortInfo.description;
+        if (portDesc.toLowerCase().includes('headphones')) {
+            baseLabel = 'Headphones';
+        }
+        else if (portDesc.toLowerCase().includes('hdmi') ||
+            portDesc.toLowerCase().includes('displayport')) {
+            baseLabel = `HDMI Display`;
+        }
+        else if (portDesc.toLowerCase().includes('microphone') ||
+            portDesc.toLowerCase().includes('mic')) {
+            baseLabel = 'Microphone';
+        }
+        else if (portDesc.toLowerCase().includes('line')) {
+            baseLabel = `Line ${isInput ? 'In' : 'Out'}`;
+        }
+        else if (portDesc.toLowerCase().includes('speaker')) {
+            baseLabel = 'Speakers';
+        }
+        else {
+            baseLabel = `${portDesc} (${isInput ? 'Input' : 'Output'})`;
+        }
+    }
+    else if (device.displayName) {
+        baseLabel = `${device.displayName} (${isInput ? 'Input' : 'Output'})`;
+    }
+    else {
+        baseLabel = device.identifier || 'Unknown Audio Device';
+    }
+    if (device.displayName &&
+        baseLabel !== device.displayName &&
+        !baseLabel.includes(device.displayName)) {
+        baseLabel = `${device.displayName} - ${baseLabel}`;
+    }
+    if (formFactor && formFactor !== 'internal' && !baseLabel.includes(formFactor)) {
+        baseLabel = `${baseLabel} (${formFactor.charAt(0).toUpperCase() + formFactor.slice(1)})`;
+    }
+    if (bus && bus.toLowerCase() !== 'pci' && !baseLabel.includes(bus.toUpperCase())) {
+        baseLabel = `${baseLabel} (${bus.toUpperCase()})`;
+    }
+    const statusParts = [];
+    if (isDefault) {
+        statusParts.push('Default');
+    }
+    if (available !== undefined) {
+        statusParts.push(available ? 'Available' : 'Unavailable');
+    }
+    return statusParts.length > 0 ? `${baseLabel} (${statusParts.join(', ')})` : baseLabel;
+}
+function discoverPulseAudioSocket() {
+    try {
+        const findOutput = (0, child_process_1.execSync)('find /tmp -maxdepth 2 -type d -name "pulse-*" 2>/dev/null | head -1', {
+            encoding: 'utf-8',
+            timeout: 2000,
+            stdio: 'pipe',
+        }).trim();
+        if (findOutput) {
+            const socketPath = `${findOutput}/native`;
+            try {
+                (0, child_process_1.execSync)(`test -S "${socketPath}"`, { stdio: 'pipe' });
+                return socketPath;
+            }
+            catch {
+                return undefined;
+            }
+        }
+    }
+    catch (error) {
+    }
+    return undefined;
+}
+function getPulseAudioEnv() {
+    if (!pulseAudioServerPath) {
+        pulseAudioServerPath = discoverPulseAudioSocket();
+        if (pulseAudioServerPath) {
+            console.log(`Discovered PulseAudio socket: ${pulseAudioServerPath}`);
+        }
+    }
+    const env = { ...process.env };
+    if (pulseAudioServerPath) {
+        env.PULSE_SERVER = `unix:${pulseAudioServerPath}`;
+    }
+    return env;
+}
+function startPulseAudio() {
+    if (!pulseAudioServerPath) {
+        pulseAudioServerPath = discoverPulseAudioSocket();
+        if (pulseAudioServerPath) {
+            console.log(`Discovered existing PulseAudio socket: ${pulseAudioServerPath}`);
+        }
+    }
+    try {
+        const env = getPulseAudioEnv();
+        (0, child_process_1.execSync)(PULSEAUDIO_COMMANDS.INFO, {
+            encoding: 'utf-8',
+            timeout: PULSEAUDIO_TIMEOUTS.INFO_CHECK,
+            stdio: 'pipe',
+            env,
+        });
+        console.log('PulseAudio is running and accessible');
+        loadAlsaDevicesIntoPulseAudio();
+        return true;
+    }
+    catch (error) {
+        const errorMsg = error instanceof Error ? error.message : String(error);
+        console.log('PulseAudio not accessible:', errorMsg);
+        console.log('Attempting to start PulseAudio...');
+    }
+    try {
+        (0, child_process_1.execSync)(PULSEAUDIO_COMMANDS.KILL, {
+            timeout: PULSEAUDIO_TIMEOUTS.KILL,
+            stdio: 'pipe',
+        });
+        (0, child_process_1.execSync)(PULSEAUDIO_COMMANDS.WAIT, { stdio: 'pipe' });
+        (0, child_process_1.execSync)(PULSEAUDIO_COMMANDS.START_DAEMON, {
+            timeout: PULSEAUDIO_TIMEOUTS.START,
+            stdio: 'pipe',
+        });
+        (0, child_process_1.execSync)(PULSEAUDIO_COMMANDS.WAIT, { stdio: 'pipe' });
+        pulseAudioServerPath = discoverPulseAudioSocket();
+        if (pulseAudioServerPath) {
+            console.log(`Discovered PulseAudio socket: ${pulseAudioServerPath}`);
+        }
+        else {
+            console.log('Warning: Could not discover PulseAudio socket path');
+        }
+        const env = getPulseAudioEnv();
+        (0, child_process_1.execSync)(PULSEAUDIO_COMMANDS.INFO, {
+            timeout: PULSEAUDIO_TIMEOUTS.INFO_CHECK,
+            stdio: 'pipe',
+            env,
+        });
+        console.log('✓ PulseAudio started successfully');
+        loadAlsaDevicesIntoPulseAudio();
+        return true;
+    }
+    catch (error) {
+        console.error('✗ Failed to start PulseAudio:', error instanceof Error ? error.message : String(error));
+        console.error('  Hint: Make sure no other PulseAudio instances are running as different users');
+        return false;
+    }
+}
+function parseAlsaDevices(aplayOutput) {
+    const devices = [];
+    const regex = /card (\d+): ([^,]+), device (\d+): ([^\[]+)\[([^\]]+)\]/g;
+    let match;
+    while ((match = regex.exec(aplayOutput)) !== null) {
+        const card = parseInt(match[1], 10);
+        const device = parseInt(match[3], 10);
+        const name = match[5].trim();
+        devices.push({
+            card,
+            device,
+            name,
+            hwString: `hw:${card},${device}`,
+        });
+    }
+    return devices;
+}
+function checkExistingSink(hwString, isInput) {
+    try {
+        const command = isInput ? PULSEAUDIO_COMMANDS.LIST_SOURCES : PULSEAUDIO_COMMANDS.LIST_SINKS;
+        const env = getPulseAudioEnv();
+        const output = (0, child_process_1.execSync)(command, {
+            encoding: 'utf-8',
+            timeout: 3000,
+            env,
+        });
+        const [card, device] = hwString.replace('hw:', '').split(',');
+        const devicePattern = new RegExp(`alsa\\.device\\s*=\\s*"${device}"`, 'i');
+        const cardPattern = new RegExp(`alsa\\.card\\s*=\\s*"${card}"`, 'i');
+        const blocks = output.split(/^(Sink|Source) #/m);
+        for (const block of blocks) {
+            if (cardPattern.test(block) && devicePattern.test(block)) {
+                return true;
+            }
+        }
+        return false;
+    }
+    catch (error) {
+        return false;
+    }
+}
+function createPulseAudioSink(alsaDevice, isInput) {
+    try {
+        const sinkName = isInput
+            ? `alsa_input_${alsaDevice.card}_${alsaDevice.device}`
+            : `alsa_output_${alsaDevice.card}_${alsaDevice.device}`;
+        const safeDescription = `${alsaDevice.name}_${alsaDevice.hwString}`.replace(/[^a-zA-Z0-9_-]/g, '_');
+        const command = isInput
+            ? PULSEAUDIO_COMMANDS.LOAD_ALSA_SOURCE(alsaDevice.hwString, sinkName, safeDescription)
+            : PULSEAUDIO_COMMANDS.LOAD_ALSA_SINK(alsaDevice.hwString, sinkName, safeDescription);
+        console.log(`  Creating ${isInput ? 'source' : 'sink'} for ${alsaDevice.hwString}: ${alsaDevice.name}`);
+        const env = getPulseAudioEnv();
+        (0, child_process_1.execSync)(command, {
+            timeout: 5000,
+            stdio: 'pipe',
+            env,
+        });
+        return true;
+    }
+    catch (error) {
+        console.log(`  Failed to create ${isInput ? 'source' : 'sink'} for ${alsaDevice.hwString}:`, error instanceof Error ? error.message : String(error));
+        return false;
+    }
+}
+function loadAlsaDevicesIntoPulseAudio() {
+    try {
+        console.log('Detecting ALSA hardware and ensuring PulseAudio coverage...');
+        try {
+            const env = getPulseAudioEnv();
+            const modules = (0, child_process_1.execSync)(PULSEAUDIO_COMMANDS.LIST_MODULES, {
+                encoding: 'utf-8',
+                timeout: PULSEAUDIO_TIMEOUTS.LIST_MODULES,
+                env,
+            });
+            if (!modules.includes('module-alsa-card')) {
+                console.log('  Loading ALSA card module for auto-detection...');
+                (0, child_process_1.execSync)(PULSEAUDIO_COMMANDS.LOAD_ALSA_MODULE, {
+                    timeout: PULSEAUDIO_TIMEOUTS.LOAD_MODULE,
+                    stdio: 'pipe',
+                    env,
+                });
+            }
+        }
+        catch (error) {
+            console.log('  Note: Base ALSA module load failed (will create sinks manually)');
+        }
+        let outputDevices = [];
+        let inputDevices = [];
+        try {
+            const aplayOutput = (0, child_process_1.execSync)(ALSA_COMMANDS.APLAY_LIST, {
+                encoding: 'utf-8',
+                timeout: 3000,
+            });
+            outputDevices = parseAlsaDevices(aplayOutput);
+            console.log(`  Found ${outputDevices.length} ALSA output device(s)`);
+        }
+        catch (error) {
+            console.log('  No ALSA output devices found or aplay failed');
+        }
+        try {
+            const arecordOutput = (0, child_process_1.execSync)(ALSA_COMMANDS.ARECORD_LIST, {
+                encoding: 'utf-8',
+                timeout: 3000,
+            });
+            inputDevices = parseAlsaDevices(arecordOutput);
+            console.log(`  Found ${inputDevices.length} ALSA input device(s)`);
+        }
+        catch (error) {
+            console.log('  No ALSA input devices found or arecord failed');
+        }
+        let createdCount = 0;
+        for (const device of outputDevices) {
+            if (!checkExistingSink(device.hwString, false)) {
+                if (createPulseAudioSink(device, false)) {
+                    createdCount++;
+                }
+            }
+            else {
+                console.log(`  ✓ Sink already exists for ${device.hwString}: ${device.name}`);
+            }
+        }
+        for (const device of inputDevices) {
+            if (!checkExistingSink(device.hwString, true)) {
+                if (createPulseAudioSink(device, true)) {
+                    createdCount++;
+                }
+            }
+            else {
+                console.log(`  ✓ Source already exists for ${device.hwString}: ${device.name}`);
+            }
+        }
+        if (createdCount > 0) {
+            console.log(`✓ Created ${createdCount} PulseAudio sink(s)/source(s) for missing hardware`);
+        }
+        else {
+            console.log('✓ All ALSA devices already have corresponding PulseAudio sinks/sources');
+        }
+    }
+    catch (error) {
+        console.log('Note: Could not complete ALSA device loading:', error instanceof Error ? error.message : String(error));
+    }
+}
+function getDefaultDevices() {
+    try {
+        const env = getPulseAudioEnv();
+        const infoOutput = (0, child_process_1.execSync)(PULSEAUDIO_COMMANDS.INFO, {
+            encoding: 'utf-8',
+            timeout: PULSEAUDIO_TIMEOUTS.INFO_CHECK,
+            env,
+        });
+        const defaultSinkMatch = infoOutput.match(/Default Sink: (.+)/);
+        const defaultSourceMatch = infoOutput.match(/Default Source: (.+)/);
+        return {
+            defaultSink: defaultSinkMatch?.[1]?.trim(),
+            defaultSource: defaultSourceMatch?.[1]?.trim(),
+        };
+    }
+    catch (error) {
+        console.error('Failed to get default devices:', error);
+        return {};
+    }
+}
+function getAudioDevices() {
+    if (!startPulseAudio()) {
+        console.error('Audio detection failed: PulseAudio unavailable');
+        return undefined;
+    }
+    const { defaultSink, defaultSource } = getDefaultDevices();
+    console.log(`Default sink: ${defaultSink}, Default source: ${defaultSource}`);
+    const outputs = [];
+    const inputs = [];
+    try {
+        const env = getPulseAudioEnv();
+        const sinksOutput = (0, child_process_1.execSync)(PULSEAUDIO_COMMANDS.LIST_SINKS, {
+            encoding: 'utf-8',
+            timeout: PULSEAUDIO_TIMEOUTS.LIST_DEVICES,
+            env,
+        });
+        sinksOutput
+            .split(/^Sink #/m)
+            .slice(1)
+            .forEach(block => {
+            const device = parseAudioDevice(block, false);
+            if (device) {
+                const isDefault = device.identifier === defaultSink;
+                if (isDefault && device.label) {
+                    if (!device.label.includes('Default')) {
+                        if (device.label.includes('(')) {
+                            device.label = device.label.replace(')', ', Default)');
+                        }
+                        else {
+                            device.label = `${device.label} (Default)`;
+                        }
+                    }
+                }
+                outputs.push(device);
+            }
+        });
+        console.log(`Detected ${outputs.length} audio output device(s) via PulseAudio`);
+    }
+    catch (error) {
+        console.error('Failed to detect audio outputs:', error instanceof Error ? error.message : String(error));
+    }
+    try {
+        const env = getPulseAudioEnv();
+        const sourcesOutput = (0, child_process_1.execSync)(PULSEAUDIO_COMMANDS.LIST_SOURCES, {
+            encoding: 'utf-8',
+            timeout: PULSEAUDIO_TIMEOUTS.LIST_DEVICES,
+            env,
+        });
+        sourcesOutput
+            .split(/^Source #/m)
+            .slice(1)
+            .forEach(block => {
+            const device = parseAudioDevice(block, true);
+            if (device) {
+                const isDefault = device.identifier === defaultSource;
+                if (isDefault && device.label) {
+                    if (!device.label.includes('Default')) {
+                        if (device.label.includes('(')) {
+                            device.label = device.label.replace(')', ', Default)');
+                        }
+                        else {
+                            device.label = `${device.label} (Default)`;
+                        }
+                    }
+                }
+                inputs.push(device);
+            }
+        });
+        console.log(`Detected ${inputs.length} audio input device(s) via PulseAudio`);
+    }
+    catch (error) {
+        console.error('Failed to detect audio inputs:', error instanceof Error ? error.message : String(error));
+    }
+    if (outputs.length === 0 && inputs.length === 0) {
+        console.log('No audio devices detected');
+        return undefined;
+    }
+    return { outputs, inputs };
+}
 async function getSystemInformation() {
     const valueObject = {
         baseboard: '*',
@@ -40,12 +678,15 @@ async function getSystemInformation() {
     netIfaces = netIfaces.map((iface) => ({
         ...iface,
         type: iface.type ||
-            (iface.ifaceName &&
-                (iface.ifaceName.startsWith("en") || iface.ifaceName.startsWith("eth"))
-                ? "wired"
-                : "unknown"),
+            (iface.ifaceName && (iface.ifaceName.startsWith('en') || iface.ifaceName.startsWith('eth'))
+                ? 'wired'
+                : 'unknown'),
     }));
     info.networkInterfaces = netIfaces;
+    const audioDevices = getAudioDevices();
+    if (audioDevices) {
+        info.audioDevices = audioDevices;
+    }
     const systemInfo = JSON.parse(JSON.stringify(info));
     return systemInfo;
 }