@phystack/hub-device 4.5.2-dev → 4.5.4-dev

package/src/sysinfo/node.ts

@@ -1,6 +1,6 @@
 import si from 'systeminformation';
 import { execSync } from 'child_process';
-import { AudioDevice, AudioDevices, AudioPort } from '../types/twin.types';
+import { AudioDevice, AudioDevices, AudioPort, AudioProfile } from '../types/twin.types';
 
 // ============================================================================
 // PULSEAUDIO COMMANDS
@@ -14,6 +14,7 @@ const PULSEAUDIO_COMMANDS = {
   LOAD_ALSA_MODULE: 'pactl load-module module-alsa-card',
   LIST_SINKS: 'pactl list sinks',
   LIST_SOURCES: 'pactl list sources',
+  LIST_CARDS: 'pactl list cards',
   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) =>
@@ -29,6 +30,9 @@ const PULSEAUDIO_TIMEOUTS = {
   LIST_DEVICES: 5000,
 } as const;
 
+// Store discovered PulseAudio server socket path
+let pulseAudioServerPath: string | undefined;
+
 /**
  * Build audio device description
  */
@@ -70,6 +74,18 @@ function parseAudioDevice(block: string, isInput: boolean): AudioDevice | null {
       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 =')) {
+      // Extract card number for later card name construction
+      const cardMatch = trimmed.match(/alsa\.card\s*=\s*"(\d+)"/);
+      if (cardMatch) {
+        (device as any).cardNumber = cardMatch[1];
+      }
+    } else if (trimmed.includes('alsa.card_name =')) {
+      // Extract 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);
@@ -104,11 +120,25 @@ function parseAudioDevice(block: string, isInput: boolean): AudioDevice | null {
           if (portDetails) {
             const typeMatch = portDetails.match(/type:\s*([^,]+)/);
             const priorityMatch = portDetails.match(/priority:\s*(\d+)/);
-            const availableMatch = portDetails.match(/available|availability unknown/);
+            // Parse availability: "available", "available: yes", "not available", "availability unknown"
+            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) port.available = availableMatch[0] === 'available';
+
+            // Determine availability: true if "available" or "available: yes", false otherwise
+            if (availableMatch) {
+              const availStr = availableMatch[0].toLowerCase();
+              if (availStr.includes('not available') || availStr.includes('availability unknown')) {
+                port.available = false;
+              } else if (availStr.includes('available: no')) {
+                port.available = false;
+              } else {
+                port.available = true; // "available" or "available: yes"
+              }
+            }
           }
 
           console.log(`[Audio] Parsed port: ${portName} - ${portDescription}`);
@@ -124,6 +154,12 @@ function parseAudioDevice(block: string, isInput: boolean): AudioDevice | null {
     } else if (trimmed.includes('device.vendor.name =')) {
       const match = trimmed.match(/"([^"]+)"/);
       if (match && !device.description) device.description = match[1];
+    } else if (trimmed.includes('device.product.name =')) {
+      // Extract product name (e.g., "LG ULTRAFINE" for HDMI displays)
+      const match = trimmed.match(/"([^"]+)"/);
+      if (match) {
+        (device as any).productName = match[1];
+      }
     }
   }
 
@@ -137,9 +173,115 @@ function parseAudioDevice(block: string, isInput: boolean): AudioDevice | null {
   // Add ports if any were found
   if (ports.length > 0) {
     device.availablePorts = ports;
-    console.log(`[Audio] Device ${device.identifier} has ${ports.length} ports, active: ${device.activePort}`);
+    console.log(
+      `[Audio] Device ${device.identifier} has ${ports.length} ports, active: ${device.activePort}`
+    );
+
+    // Determine overall device availability (true if at least one port is available)
+    const availablePorts = ports.filter(p => p.available === true);
+    device.available = availablePorts.length > 0;
   } else {
     console.log(`[Audio] Device ${device.identifier} has NO ports detected`);
+    device.available = false;
+  }
+
+  // Extract card information from device identifier
+  // 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}
+  // Where prefix can be: alsa, bluez, or other PulseAudio modules
+  // Note: Some devices (like Bluetooth) may not have a profile suffix
+
+  // Try standard format with profile: {prefix}_{type}.{card_id}.{profile}
+  let cardMatch = device.identifier?.match(
+    /^([^_]+)_(output|input|sink|source)\.([^.]+(?:\.[^.]+)*)\.(.+)$/
+  );
+  if (cardMatch) {
+    const prefix = cardMatch[1]; // e.g., "alsa", "bluez"
+    const cardId = cardMatch[3]; // e.g., "pci-0000_00_1f.3", "usb-046d_08d9-01", "XX_XX_XX_XX_XX_XX"
+    const profile = cardMatch[4]; // e.g., "analog-stereo"
+
+    // Map device type to profile type
+    const deviceType = cardMatch[2]; // "output", "input", "sink", "source"
+    const profileType = deviceType === 'input' || deviceType === 'source' ? 'input' : 'output';
+
+    // Construct card name: prefix + "_card." + card_id
+    // e.g., "alsa_card.pci-0000_00_1f.3", "bluez_card.XX_XX_XX_XX_XX_XX"
+    device.cardName = `${prefix}_card.${cardId}`;
+    device.cardProfile = `${profileType}:${profile}`;
+  } else {
+    // Try format without profile: {prefix}_{type}.{card_id} (e.g., Bluetooth)
+    cardMatch = device.identifier?.match(/^([^_]+)_(output|input|sink|source)\.(.+)$/);
+    if (cardMatch) {
+      const prefix = cardMatch[1]; // e.g., "bluez"
+      const cardId = cardMatch[3]; // e.g., "XX_XX_XX_XX_XX_XX"
+
+      // Construct card name: prefix + "_card." + card_id
+      device.cardName = `${prefix}_card.${cardId}`;
+      // No profile for these devices (Bluetooth devices don't have profiles in the identifier)
+      // Profile will be determined from card information if available
+    } else {
+      // Fallback: Try to extract card number from identifier format "alsa_output_0_3"
+      const altMatch = device.identifier?.match(/^([^_]+)_(output|input|sink|source)_(\d+)_(\d+)$/);
+      if (altMatch) {
+        const cardNumber = altMatch[3];
+        // Try to find card name from pactl list cards (supports any card type)
+        try {
+          const env = getPulseAudioEnv();
+          const cardsOutput = execSync('pactl list cards short', {
+            encoding: 'utf-8',
+            timeout: 2000,
+            stdio: 'pipe',
+            env,
+          });
+          const cardLine = cardsOutput.split('\n').find(line => line.includes(`card${cardNumber}`));
+          if (cardLine) {
+            // Match any card name format: {prefix}_card.{identifier}
+            // e.g., "alsa_card.pci-0000_00_1f.3", "bluez_card.XX_XX_XX_XX_XX_XX"
+            const cardNameMatch = cardLine.match(/([^_\s]+_card\.[^\s]+)/);
+            if (cardNameMatch) {
+              device.cardName = cardNameMatch[1];
+            }
+          }
+        } catch (error) {
+          // Card lookup failed, continue without it
+        }
+      } else {
+        // Final fallback: use card number from device properties
+        const cardNumber = (device as any).cardNumber;
+        if (cardNumber !== undefined) {
+          try {
+            const env = getPulseAudioEnv();
+            const cardsOutput = execSync('pactl list cards short', {
+              encoding: 'utf-8',
+              timeout: 2000,
+              stdio: 'pipe',
+              env,
+            });
+            const cardLine = cardsOutput
+              .split('\n')
+              .find(line => line.includes(`card${cardNumber}`));
+            if (cardLine) {
+              // Match any card name format: {prefix}_card.{identifier}
+              const cardNameMatch = cardLine.match(/([^_\s]+_card\.[^\s]+)/);
+              if (cardNameMatch) {
+                device.cardName = cardNameMatch[1];
+              }
+            }
+          } catch (error) {
+            // Card lookup failed, continue without it
+          }
+        }
+      }
+    }
+  }
+
+  // Always set available flag - if no ports, device is still available if it exists
+  if (device.available === undefined) {
+    device.available = true; // Default to available if we can't determine
   }
 
   // Build rich description
@@ -153,20 +295,153 @@ function parseAudioDevice(block: string, isInput: boolean): AudioDevice | null {
     );
   }
 
+  // Create human-readable label based on active port and product name
+  device.label = createDeviceLabel(device, ports, isInput);
+
   return device as AudioDevice;
 }
 
+/**
+ * Create a human-readable label for an audio device based on ports and product info
+ */
+function createDeviceLabel(
+  device: Partial<AudioDevice>,
+  ports: AudioPort[],
+  isInput: boolean
+): string {
+  const productName = (device as any).productName;
+  const activePort = device.activePort;
+
+  // Find the active port in the ports list
+  const activePortInfo = ports.find(p => p.name === activePort);
+
+  // Priority 1: Use product name if available (e.g., "LG ULTRAFINE")
+  if (productName) {
+    return `${productName} (${isInput ? 'Microphone' : 'Speaker'})`;
+  }
+
+  // Priority 2: Use active port description if available
+  if (activePortInfo && activePortInfo.description) {
+    const portDesc = activePortInfo.description;
+
+    // Map common port descriptions to user-friendly names
+    if (portDesc.toLowerCase().includes('headphones')) {
+      return 'Headphones';
+    } else if (
+      portDesc.toLowerCase().includes('hdmi') ||
+      portDesc.toLowerCase().includes('displayport')
+    ) {
+      return `HDMI Display (${portDesc})`;
+    } else if (
+      portDesc.toLowerCase().includes('microphone') ||
+      portDesc.toLowerCase().includes('mic')
+    ) {
+      return 'Microphone';
+    } else if (portDesc.toLowerCase().includes('line')) {
+      return `Line ${isInput ? 'In' : 'Out'}`;
+    } else if (portDesc.toLowerCase().includes('speaker')) {
+      return 'Speakers';
+    } else {
+      // Use port description with device type
+      return `${portDesc} (${isInput ? 'Input' : 'Output'})`;
+    }
+  }
+
+  // Priority 3: Use card profile information
+  if (device.cardProfile) {
+    if (device.cardProfile.includes('analog-stereo')) {
+      return isInput ? 'Analog Microphone' : 'Analog Speakers';
+    } else if (device.cardProfile.includes('hdmi-stereo')) {
+      return 'HDMI Audio';
+    } else if (device.cardProfile.includes('hdmi-surround')) {
+      return 'HDMI Surround Audio';
+    }
+  }
+
+  // Priority 4: Use display name with device type
+  if (device.displayName) {
+    return `${device.displayName} (${isInput ? 'Input' : 'Output'})`;
+  }
+
+  // Fallback: Use identifier
+  return device.identifier || 'Unknown Audio Device';
+}
+
+/**
+ * Discover PulseAudio socket path by finding the socket file
+ * @internal
+ * Exported for use in device-phyos audio control
+ */
+export function discoverPulseAudioSocket(): string | undefined {
+  try {
+    // Find PulseAudio socket directories in /tmp
+    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`;
+      // Verify the socket file exists
+      try {
+        execSync(`test -S "${socketPath}"`, { stdio: 'pipe' });
+        return socketPath;
+      } catch {
+        return undefined;
+      }
+    }
+  } catch (error) {
+    // Socket discovery failed, will try without it
+  }
+  return undefined;
+}
+
+/**
+ * Get environment variables for execSync calls to include PULSE_SERVER if discovered
+ * @internal
+ * Exported for use in device-phyos audio control
+ */
+export function getPulseAudioEnv(): NodeJS.ProcessEnv {
+  // Try to discover socket if not already discovered
+  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;
+}
+
 /**
  * Start PulseAudio daemon if not running
  * Service runs as root, so user mode has full hardware access
  */
 function startPulseAudio(): boolean {
+  // If we don't have the socket path yet, try to discover it
+  if (!pulseAudioServerPath) {
+    pulseAudioServerPath = discoverPulseAudioSocket();
+    if (pulseAudioServerPath) {
+      console.log(`Discovered existing PulseAudio socket: ${pulseAudioServerPath}`);
+    }
+  }
+
   // Check if already 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');
 
@@ -200,10 +475,20 @@ function startPulseAudio(): boolean {
     // Wait for startup
     execSync(PULSEAUDIO_COMMANDS.WAIT, { stdio: 'pipe' });
 
+    // Discover the socket path
+    pulseAudioServerPath = discoverPulseAudioSocket();
+    if (pulseAudioServerPath) {
+      console.log(`Discovered PulseAudio socket: ${pulseAudioServerPath}`);
+    } else {
+      console.log('Warning: Could not discover PulseAudio socket path');
+    }
+
     // Verify it's running
+    const env = getPulseAudioEnv();
     execSync(PULSEAUDIO_COMMANDS.INFO, {
       timeout: PULSEAUDIO_TIMEOUTS.INFO_CHECK,
       stdio: 'pipe',
+      env,
     });
 
     console.log('✓ PulseAudio started successfully');
@@ -261,9 +546,11 @@ function parseAlsaDevices(aplayOutput: string): AlsaDevice[] {
 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,
     });
 
     // Check if any sink/source references this ALSA device
@@ -299,23 +586,32 @@ function createPulseAudioSink(alsaDevice: AlsaDevice, isInput: boolean): boolean
 
     // Simplify description to avoid quoting/escaping issues with PulseAudio
     // Replace spaces and special chars with underscores
-    const safeDescription = `${alsaDevice.name}_${alsaDevice.hwString}`.replace(/[^a-zA-Z0-9_-]/g, '_');
+    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}`);
+    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));
+    console.log(
+      `  Failed to create ${isInput ? 'source' : 'sink'} for ${alsaDevice.hwString}:`,
+      error instanceof Error ? error.message : String(error)
+    );
     return false;
   }
 }
@@ -334,9 +630,11 @@ function loadAlsaDevicesIntoPulseAudio(): void {
 
     // Step 1: Load the 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')) {
@@ -344,6 +642,7 @@ function loadAlsaDevicesIntoPulseAudio(): void {
         execSync(PULSEAUDIO_COMMANDS.LOAD_ALSA_MODULE, {
           timeout: PULSEAUDIO_TIMEOUTS.LOAD_MODULE,
           stdio: 'pipe',
+          env,
         });
       }
     } catch (error) {
@@ -404,7 +703,6 @@ function loadAlsaDevicesIntoPulseAudio(): void {
     } else {
       console.log('✓ All ALSA devices already have corresponding PulseAudio sinks/sources');
     }
-
   } catch (error) {
     console.log(
       'Note: Could not complete ALSA device loading:',
@@ -418,9 +716,11 @@ function loadAlsaDevicesIntoPulseAudio(): void {
  */
 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: (.+)/);
@@ -436,6 +736,111 @@ function getDefaultDevices(): { defaultSink?: string; defaultSource?: string } {
   }
 }
 
+/**
+ * Parse card profiles from pactl list cards output
+ */
+function parseCardProfiles(cardBlock: string): AudioProfile[] {
+  const profiles: AudioProfile[] = [];
+  const lines = cardBlock.split('\n');
+  let inProfilesSection = false;
+
+  // Extract port mappings from Ports section
+  const portProfileMap: Map<string, string[]> = new Map();
+  let inPortsSection = false;
+  let currentPortName = '';
+
+  for (const line of lines) {
+    const trimmed = line.trim();
+
+    // Parse Ports section to map ports to profiles
+    if (trimmed.startsWith('Ports:')) {
+      inPortsSection = true;
+      continue;
+    }
+
+    if (inPortsSection && trimmed.startsWith('Part of profile(s):')) {
+      const profileList = trimmed.replace('Part of profile(s):', '').trim();
+      if (currentPortName) {
+        portProfileMap.set(
+          currentPortName,
+          profileList.split(',').map(p => p.trim())
+        );
+      }
+      continue;
+    }
+
+    if (inPortsSection) {
+      if (trimmed.match(/^[a-z]+-[a-z]+-[^:]+:/)) {
+        currentPortName = trimmed.split(':')[0].trim();
+      } else if (trimmed.startsWith('Active Profile:') || trimmed.match(/^[A-Z]/)) {
+        inPortsSection = false;
+      }
+    }
+
+    // Parse Profiles section
+    if (trimmed.startsWith('Profiles:')) {
+      inProfilesSection = true;
+      continue;
+    }
+
+    if (inProfilesSection) {
+      if (trimmed.startsWith('Active Profile:') || trimmed.startsWith('Ports:')) {
+        inProfilesSection = false;
+        continue;
+      }
+
+      // Parse profile line: "output:analog-stereo: Analog Stereo Output (sinks: 1, sources: 0, priority: 39268, available: yes)"
+      const profileMatch = trimmed.match(/^([^:]+):\s*(.+?)\s*\([^)]+available:\s*(yes|no)\)/);
+      if (profileMatch) {
+        const profileName = profileMatch[1].trim();
+        const description = profileMatch[2].trim();
+        const available = profileMatch[3].trim() === 'yes';
+
+        // Find ports that belong to this profile
+        const ports: string[] = [];
+        for (const [portName, profileList] of portProfileMap.entries()) {
+          if (profileList.includes(profileName)) {
+            ports.push(portName);
+          }
+        }
+
+        profiles.push({
+          profile: profileName,
+          available,
+          description,
+          ports,
+        });
+      }
+    }
+  }
+
+  return profiles;
+}
+
+/**
+ * Get card profiles for a specific card
+ */
+function getCardProfiles(cardName: string): AudioProfile[] {
+  try {
+    const env = getPulseAudioEnv();
+    const cardsOutput = execSync(PULSEAUDIO_COMMANDS.LIST_CARDS, {
+      encoding: 'utf-8',
+      timeout: PULSEAUDIO_TIMEOUTS.LIST_DEVICES,
+      env,
+    });
+
+    const cardBlocks = cardsOutput.split(/^Card #/m);
+    for (const block of cardBlocks.slice(1)) {
+      if (block.includes(`Name: ${cardName}`)) {
+        return parseCardProfiles(block);
+      }
+    }
+  } catch (error) {
+    console.log(`Failed to get profiles for card ${cardName}:`, error);
+  }
+  return [];
+}
+
 /**
  * Get available audio input/output devices using PulseAudio
  */
@@ -451,12 +856,15 @@ function getAudioDevices(): AudioDevices | undefined {
 
   const outputs: AudioDevice[] = [];
   const inputs: AudioDevice[] = [];
+  const cardProfilesCache: Map<string, AudioProfile[]> = new Map();
 
   // 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)
@@ -466,6 +874,15 @@ function getAudioDevices(): AudioDevices | undefined {
         if (device) {
           // Mark as default if it matches the default sink
           device.isDefault = device.identifier === defaultSink;
+
+          // Add available profiles if cardName is available
+          if (device.cardName && !cardProfilesCache.has(device.cardName)) {
+            cardProfilesCache.set(device.cardName, getCardProfiles(device.cardName));
+          }
+          if (device.cardName) {
+            device.availableProfiles = cardProfilesCache.get(device.cardName) || [];
+          }
+
           outputs.push(device);
         }
       });
@@ -479,9 +896,11 @@ function getAudioDevices(): AudioDevices | undefined {
 
   // 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)
@@ -491,6 +910,15 @@ function getAudioDevices(): AudioDevices | undefined {
         if (device) {
           // Mark as default if it matches the default source
           device.isDefault = device.identifier === defaultSource;
+
+          // Add available profiles if cardName is available
+          if (device.cardName && !cardProfilesCache.has(device.cardName)) {
+            cardProfilesCache.set(device.cardName, getCardProfiles(device.cardName));
+          }
+          if (device.cardName) {
+            device.availableProfiles = cardProfilesCache.get(device.cardName) || [];
+          }
+
           inputs.push(device);
         }
       });

package/src/types/twin.types.ts

@@ -337,6 +337,13 @@ export interface AudioPort {
   available?: boolean;  // Whether port is available
 }
 
+export interface AudioProfile {
+  profile: string;  // Profile name (e.g., "output:hdmi-stereo")
+  available: boolean;  // Whether profile is available
+  description: string;  // Profile description (e.g., "Digital Stereo (HDMI) Output")
+  ports: string[];  // Ports available in this profile (e.g., ["hdmi-output-0"])
+}
+
 export interface AudioDevice {
   identifier: string;
   displayName: string;
@@ -348,6 +355,11 @@ export interface AudioDevice {
   isDefault?: boolean;  // Whether this is the system default device
   activePort?: string;  // Currently active port (e.g., "analog-output-headphones")
   availablePorts?: AudioPort[];  // Available ports for this device
+  cardName?: string;  // Card name (e.g., "alsa_card.pci-0000_00_1f.3")
+  cardProfile?: string;  // Card profile (e.g., "output:analog-stereo")
+  label?: string;  // Human-readable label for the device (e.g., "Headphones", "HDMI Display")
+  available?: boolean;  // Overall device availability (true if at least one port is available)
+  availableProfiles?: AudioProfile[];  // All available profiles for this card
 }
 
 export interface AudioDevices {