@phystack/hub-device 4.4.45 → 4.4.47

package/src/sysinfo/node.ts

@@ -1,5 +1,876 @@
 import si from 'systeminformation';
-// import { execSync } from 'child_process';
+import { execSync } from 'child_process';
+import {
+  AudioDevice,
+  AudioDevices,
+  AudioPort,
+  AvailabilityStatus,
+} from '../types/twin.types';
+
+/**
+ * PulseAudio commands
+ */
+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: string, sinkName: string, description: string) =>
+    `pactl load-module module-alsa-sink device=${hwDevice} sink_name=${sinkName} sink_properties="device.description=${description}"`,
+  LOAD_ALSA_SOURCE: (hwDevice: string, sourceName: string, description: string) =>
+    `pactl load-module module-alsa-source device=${hwDevice} source_name=${sourceName} source_properties="device.description=${description}"`,
+} as const;
+
+const ALSA_COMMANDS = {
+  APLAY_LIST: 'aplay -l 2>/dev/null',
+  ARECORD_LIST: 'arecord -l 2>/dev/null',
+} as const;
+
+const PULSEAUDIO_TIMEOUTS = {
+  INFO_CHECK: 2000,
+  KILL: 2000,
+  START: 5000,
+  LIST_MODULES: 2000,
+  LOAD_MODULE: 3000,
+  LIST_DEVICES: 5000,
+} as const;
+
+/** Cached PulseAudio server socket path discovered at runtime */
+let pulseAudioServerPath: string | undefined;
+
+/**
+ * Parses a PulseAudio device block and extracts device metadata
+ *
+ * @param block - Raw PulseAudio device block text from `pactl list sinks` or `pactl list sources`
+ * @param isInput - Whether this is an input device (source) or output device (sink)
+ * @returns Parsed AudioDevice object or null if device should be skipped
+ */
+function parseAudioDevice(block: string, isInput: boolean): AudioDevice | null {
+  const lines = block.split('\n');
+  const device: Partial<AudioDevice> = {};
+  const ports: AudioPort[] = [];
+  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 as any).cardNumber = cardMatch[1];
+      }
+    } else if (trimmed.includes('alsa.card_name =')) {
+      const cardNameMatch = trimmed.match(/alsa\.card_name\s*=\s*"([^"]+)"/);
+      if (cardNameMatch) {
+        (device as any).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 as any).activePort = trimmed.split('Active Port:')[1].trim();
+      console.log(`[Audio] Found active port: ${(device as any).activePort}`);
+    } else if (trimmed.startsWith('Ports:')) {
+      inPortsSection = true;
+      console.log(`[Audio] Entering ports section for device`);
+    } else if (inPortsSection) {
+      // Detect section boundary: next section starts with capital letter and no indentation
+      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/)) {
+        // Parse port line format: "analog-output-headphones: Headphones (type: Headphones, priority: 9900, availability unknown)"
+        const portMatch = trimmed.match(/^([^:]+):\s*(.+?)(?:\s*\((.+)\))?$/);
+        if (portMatch) {
+          const portName = portMatch[1].trim();
+          const portDescription = portMatch[2].trim();
+          const portDetails = portMatch[3];
+
+          const port: AudioPort = {
+            name: portName,
+            description: portDescription,
+          };
+
+          // Parse optional port metadata: type, priority, and availability
+          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);
+
+            // Parse availability:
+            if (availableMatch) {
+              const availStr = availableMatch[0].toLowerCase();
+              if (availStr.includes('availability unknown')) {
+                port.availabilityStatus = AvailabilityStatus.Unknown;
+              } else if (availStr.includes('not available') || availStr.includes('available: no')) {
+                port.availabilityStatus = AvailabilityStatus.Unavailable;
+              } else if (availStr.includes('available: yes')) {
+                port.availabilityStatus = AvailabilityStatus.Available;
+              }
+              // If it just says "available" without yes/no, don't set the property
+            }
+          }
+
+          console.log(`[Audio] Parsed port: ${portName} - ${portDescription}`);
+          ports.push(port);
+        }
+      }
+    } else if (trimmed.includes('device.product.name =')) {
+      const match = trimmed.match(/"([^"]+)"/);
+      if (match) {
+        (device as any).productName = match[1];
+      }
+    } else if (trimmed.includes('device.form_factor =')) {
+      const match = trimmed.match(/"([^"]+)"/);
+      if (match) (device as any).formFactor = match[1];
+    } else if (trimmed.includes('device.bus =')) {
+      const match = trimmed.match(/"([^"]+)"/);
+      if (match) (device as any).bus = match[1];
+    }
+  }
+
+  // Filter out monitor sources (virtual recording outputs)
+  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 as any).activePort}`
+    );
+  } else {
+    console.log(`[Audio] Device ${device.identifier} has NO ports detected`);
+  }
+
+  // Determine device availability using priority-based detection:
+  // 1. Check if any ports are available
+  // 2. If no ports, check sink/source state (RUNNING = available) or card port availability
+  const availablePorts = ports.filter(
+    p => p.availabilityStatus === AvailabilityStatus.Available
+  );
+  let deviceAvailable = availablePorts.length > 0;
+
+  // Fallback: determine availability from sink/source state or card ports when no ports detected
+  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 {
+        // Check card port availability using pactl list cards
+        try {
+          const env = getPulseAudioEnv();
+          const cardsOutput = 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];
+            // Map device number to HDMI port index (e.g., device 9 -> hdmi-output-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) {
+          // Card availability check failed, device remains unavailable
+        }
+      }
+    }
+  }
+
+  // Extract card name from device identifier using multiple format patterns:
+  // Format 1: alsa_output.pci-0000_00_1f.3.analog-stereo (standard PulseAudio ALSA format)
+  // Format 2: bluez_sink.XX_XX_XX_XX_XX_XX (Bluetooth - no profile suffix)
+  // Format 3: alsa_output.usb-046d_08d9-01.analog-stereo (USB audio)
+  // Format 4: alsa_output_0_3 (manually created sinks)
+  // Generic pattern: {prefix}_{type}.{card_id}[.{profile}] or {prefix}_{type}_{card}_{device}
+
+  let cardMatch = device.identifier?.match(
+    /^([^_]+)_(output|input|sink|source)\.([^.]+(?:\.[^.]+)*)\.(.+)$/
+  );
+  if (cardMatch) {
+    const prefix = cardMatch[1];
+    const cardId = cardMatch[3];
+    (device as any).cardName = `${prefix}_card.${cardId}`;
+  } else {
+    cardMatch = device.identifier?.match(/^([^_]+)_(output|input|sink|source)\.(.+)$/);
+    if (cardMatch) {
+      const prefix = cardMatch[1];
+      const cardId = cardMatch[3];
+      (device as any).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 = 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 as any).cardName = cardNameMatch[1];
+            }
+          }
+        } catch (error) {
+          // Card lookup failed, continue without card name
+        }
+      } else {
+        const cardNumber = (device as any).cardNumber;
+        if (cardNumber !== undefined) {
+          try {
+            const env = getPulseAudioEnv();
+            const cardsOutput = 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 as any).cardName = cardNameMatch[1];
+              }
+            }
+          } catch (error) {
+            // Card lookup failed, continue without card name
+          }
+        }
+      }
+    }
+  }
+
+  // Generate human-readable label incorporating device metadata
+  // Note: isDefault status will be set later when default devices are known
+  device.label = createDeviceLabel(
+    device,
+    ports,
+    isInput,
+    (device as any).formFactor,
+    (device as any).bus,
+    false,
+    deviceAvailable,
+    (device as any).activePort
+  );
+
+  // Remove temporary fields used only for label generation
+  // All metadata is consolidated in the label field
+  const cleanDevice: Partial<AudioDevice> = {
+    identifier: device.identifier,
+    volume: device.volume,
+    muted: device.muted,
+    availablePorts: device.availablePorts,
+    label: device.label,
+  };
+
+  return cleanDevice as AudioDevice;
+}
+
+/**
+ * Generates a human-readable label for an audio device
+ * Incorporates device metadata: formFactor, bus, isDefault, available, and activePort
+ *
+ * @param device - Partial AudioDevice object containing device properties
+ * @param ports - Array of available audio ports for this device
+ * @param isInput - Whether this is an input device (source) or output device (sink)
+ * @param formFactor - Device form factor (e.g., "internal", "external")
+ * @param bus - Device bus type (e.g., "pci", "usb")
+ * @param isDefault - Whether this device is the default device
+ * @param available - Whether the device is currently available
+ * @param activePort - The currently active port identifier
+ * @returns Human-readable label string
+ */
+function createDeviceLabel(
+  device: Partial<AudioDevice>,
+  ports: AudioPort[],
+  isInput: boolean,
+  formFactor?: string,
+  bus?: string,
+  isDefault?: boolean,
+  available?: boolean,
+  activePort?: string
+): string {
+  const productName = (device as any).productName;
+  let baseLabel = '';
+
+  const activePortInfo = activePort ? ports.find(p => p.name === activePort) : undefined;
+
+  // Label generation priority: product name > active port > display name > identifier
+  if (productName) {
+    baseLabel = `${productName} (${isInput ? 'Microphone' : 'Speaker'})`;
+  } else if (activePortInfo && activePortInfo.description) {
+    const portDesc = activePortInfo.description;
+
+    // Map common port descriptions to user-friendly names
+    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';
+  }
+
+  // Append display name if not already included
+  if (
+    device.displayName &&
+    baseLabel !== device.displayName &&
+    !baseLabel.includes(device.displayName)
+  ) {
+    baseLabel = `${device.displayName} - ${baseLabel}`;
+  }
+
+  // Append form factor if external device
+  if (formFactor && formFactor !== 'internal' && !baseLabel.includes(formFactor)) {
+    baseLabel = `${baseLabel} (${formFactor.charAt(0).toUpperCase() + formFactor.slice(1)})`;
+  }
+
+  // Append bus type if non-PCI
+  if (bus && bus.toLowerCase() !== 'pci' && !baseLabel.includes(bus.toUpperCase())) {
+    baseLabel = `${baseLabel} (${bus.toUpperCase()})`;
+  }
+
+  // Append status indicators
+  const statusParts: string[] = [];
+  if (isDefault) {
+    statusParts.push('Default');
+  }
+  if (available !== undefined) {
+    statusParts.push(available ? 'Available' : 'Unavailable');
+  }
+
+  return statusParts.length > 0 ? `${baseLabel} (${statusParts.join(', ')})` : baseLabel;
+}
+
+/**
+ * Discovers the PulseAudio socket path by locating the socket file
+ *
+ * @internal
+ * Exported for use in device-phyos audio control module
+ *
+ * @returns The socket path if found, undefined otherwise
+ */
+export function discoverPulseAudioSocket(): string | undefined {
+  try {
+    const findOutput = 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 {
+        execSync(`test -S "${socketPath}"`, { stdio: 'pipe' });
+        return socketPath;
+      } catch {
+        return undefined;
+      }
+    }
+  } catch (error) {
+    // Socket discovery failed
+  }
+  return undefined;
+}
+
+/**
+ * Retrieves environment variables for execSync calls, including PULSE_SERVER if socket is discovered
+ *
+ * @internal
+ * Exported for use in device-phyos audio control module
+ *
+ * @returns Process environment with PULSE_SERVER set if socket was discovered
+ */
+export function getPulseAudioEnv(): NodeJS.ProcessEnv {
+  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;
+}
+
+/**
+ * Starts the PulseAudio daemon if not already running
+ * Service runs as root, providing full hardware access in user mode
+ *
+ * @returns true if PulseAudio is running and accessible, false otherwise
+ */
+function startPulseAudio(): boolean {
+  if (!pulseAudioServerPath) {
+    pulseAudioServerPath = discoverPulseAudioSocket();
+    if (pulseAudioServerPath) {
+      console.log(`Discovered existing PulseAudio socket: ${pulseAudioServerPath}`);
+    }
+  }
+
+  // Verify PulseAudio is running and accessible
+  try {
+    const env = getPulseAudioEnv();
+    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...');
+  }
+
+  // Start fresh PulseAudio instance as current user (root)
+  try {
+    execSync(PULSEAUDIO_COMMANDS.KILL, {
+      timeout: PULSEAUDIO_TIMEOUTS.KILL,
+      stdio: 'pipe',
+    });
+
+    execSync(PULSEAUDIO_COMMANDS.WAIT, { stdio: 'pipe' });
+
+    execSync(PULSEAUDIO_COMMANDS.START_DAEMON, {
+      timeout: PULSEAUDIO_TIMEOUTS.START,
+      stdio: 'pipe',
+    });
+
+    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();
+    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;
+  }
+}
+
+/**
+ * ALSA hardware device information
+ */
+interface AlsaDevice {
+  card: number;
+  device: number;
+  name: string;
+  hwString: string; // e.g., "hw:0,0"
+}
+
+/**
+ * Parses ALSA device list output and extracts hardware device information
+ *
+ * @param aplayOutput - Raw output from `aplay -l` or `arecord -l` command
+ * @returns Array of parsed ALSA device objects
+ */
+function parseAlsaDevices(aplayOutput: string): AlsaDevice[] {
+  const devices: AlsaDevice[] = [];
+
+  // Parse format: "card 0: PCH [HDA Intel PCH], device 0: ALC662 rev3 Analog [ALC662 rev3 Analog]"
+  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;
+}
+
+/**
+ * Checks if a PulseAudio sink/source already exists for the specified ALSA device
+ *
+ * @param hwString - ALSA hardware string (e.g., "hw:0,0")
+ * @param isInput - Whether to check for source (input) or sink (output)
+ * @returns true if a matching sink/source exists, false otherwise
+ */
+function checkExistingSink(hwString: string, isInput: boolean): boolean {
+  try {
+    const command = isInput ? PULSEAUDIO_COMMANDS.LIST_SOURCES : PULSEAUDIO_COMMANDS.LIST_SINKS;
+    const env = getPulseAudioEnv();
+    const output = 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;
+  }
+}
+
+/**
+ * Creates a PulseAudio sink or source for the specified ALSA device
+ *
+ * @param alsaDevice - ALSA device information
+ * @param isInput - Whether to create a source (input) or sink (output)
+ * @returns true if creation succeeded, false otherwise
+ */
+function createPulseAudioSink(alsaDevice: AlsaDevice, isInput: boolean): boolean {
+  try {
+    const sinkName = isInput
+      ? `alsa_input_${alsaDevice.card}_${alsaDevice.device}`
+      : `alsa_output_${alsaDevice.card}_${alsaDevice.device}`;
+
+    // Sanitize description to avoid quoting/escaping issues
+    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();
+    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;
+  }
+}
+
+/**
+ * Ensures PulseAudio loads all ALSA devices (including input devices)
+ *
+ * Process:
+ * 1. Queries ALSA hardware to find all available devices
+ * 2. Checks what PulseAudio has already detected
+ * 3. Creates missing sinks/sources dynamically
+ * 4. Works generically across all device types
+ */
+function loadAlsaDevicesIntoPulseAudio(): void {
+  try {
+    console.log('Detecting ALSA hardware and ensuring PulseAudio coverage...');
+
+    // Load base ALSA card module for auto-detection
+    try {
+      const env = getPulseAudioEnv();
+      const modules = 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...');
+        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)');
+    }
+
+    // Query ALSA for hardware devices
+    let outputDevices: AlsaDevice[] = [];
+    let inputDevices: AlsaDevice[] = [];
+
+    try {
+      const aplayOutput = 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 = 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');
+    }
+
+    // Create missing PulseAudio sinks/sources for each ALSA device
+    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)
+    );
+  }
+}
+
+/**
+ * Retrieves the default sink and source identifiers from PulseAudio
+ *
+ * @returns Object containing defaultSink and defaultSource identifiers, or empty object on failure
+ */
+function getDefaultDevices(): { defaultSink?: string; defaultSource?: string } {
+  try {
+    const env = getPulseAudioEnv();
+    const infoOutput = 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 {};
+  }
+}
+
+/**
+ * Retrieves available audio input and output devices using PulseAudio
+ *
+ * @returns AudioDevices object containing outputs and inputs arrays, or undefined on failure
+ */
+function getAudioDevices(): AudioDevices | undefined {
+  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: AudioDevice[] = [];
+  const inputs: AudioDevice[] = [];
+
+  // Detect output devices (sinks)
+  try {
+    const env = getPulseAudioEnv();
+    const sinksOutput = 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)
+    );
+  }
+
+  // Detect input devices (sources)
+  try {
+    const env = getPulseAudioEnv();
+    const sourcesOutput = 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 };
+}
 
 export async function getSystemInformation() {
   // const now = new Date();
@@ -35,31 +906,32 @@ export async function getSystemInformation() {
   };
 
   const info = await si.get(valueObject);
-  // console.log('getAllData3', {info});
 
-  // Now get all network interfaces (this call reliably returns disabled interfaces as well).
+  // Retrieve network interfaces (includes disabled interfaces)
   let netIfaces = await si.networkInterfaces();
 
-  // Ensure netIfaces is always an array
   if (!Array.isArray(netIfaces)) {
     netIfaces = [netIfaces];
   }
 
-  // Map through the interfaces and assign a type if missing.
+  // Assign type to interfaces missing type information
   netIfaces = netIfaces.map((iface: any) => ({
     ...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'),
   }));
 
-  // Inject the full list of network interfaces into our system info.
   info.networkInterfaces = netIfaces;
 
-  // TODO: update so structure is aligned with what the browser version will output. Create a type.
+  const audioDevices = getAudioDevices();
+  if (audioDevices) {
+    info.audioDevices = audioDevices;
+  }
+
+  // TODO: Align structure with browser version output and create proper type definition
   const systemInfo = JSON.parse(JSON.stringify(info));
 
   return systemInfo;