fix: Microphone access denied

src/components/friend/frontend/components/ChatInput.tsx

@@ -170,29 +170,29 @@ export function ChatInput({ visible = true, onActiveChange, uiAlign = 'right', o
     setText('')
     setOpen(true)
 
-    // Server STT streaming via HTTP polling
-    if (sttProvider !== 'browser') {
-      serverStt.startStreaming(
-        sttProvider,
-        (text, isFinal) => {
-          handleVoiceCallResult(text, isFinal)
-        },
-        (err) => {
-          console.error('Server STT error:', err)
-          if (voiceCallActiveRef.current) {
+    // Always use server-side STT via HTTP polling.
+    // Audio capture is done server-side via cpal (in-process native addon)
+    // so no getUserMedia call is needed on the frontend — this avoids
+    // WebKitGTK permission issues on Linux.
+    serverStt.startStreaming(
+      sttProvider,
+      (text, isFinal) => {
+        handleVoiceCallResult(text, isFinal)
+      },
+      (err) => {
+        console.error('Server STT error:', err)
+        if (voiceCallActiveRef.current) {
+          // Show error text in the input bar, then end call after 3s
+          setText(`语音启动失败: ${err}`)
+          setTimeout(() => {
+            setText('')
             endVoiceCallRef.current()
-          }
-        },
-        language === 'en' ? 'en' : 'zh',
-      )
-      setRecording(true)
-      return
-    }
-
-    // Browser STT not available on WebKitGTK — use server STT as fallback
-    console.warn('Browser STT not supported, falling back to server STT')
-    setVoiceCallActive(false)
-    voiceCallActiveRef.current = false
+          }, 3000)
+        }
+      },
+      language === 'en' ? 'en' : 'zh',
+    )
+    setRecording(true)
   }, [handleVoiceCallResult, sttProvider, serverStt, language])
 
   // --- Voice Call: end ---

src/components/friend/frontend/hooks/useServerStt.ts

@@ -62,8 +62,11 @@ export function useServerStt() {
     ) => {
       // Start capture
       fetch(`${FRIEND_API_BASE}/voice/start`, { method: 'POST' })
-        .then((res) => {
-          if (!res.ok) throw new Error('STT start failed')
+        .then(async (res) => {
+          if (!res.ok) {
+            const body = await res.json().catch(() => ({}))
+            throw new Error(body.error || 'STT start failed')
+          }
           setConnected(true)
 
           // Poll for interim results every 500ms

src/friend/FriendService.ts

@@ -154,42 +154,33 @@ class FriendService {
   /**
    * Start in-process voice capture using cpal.
    * Audio is forwarded to the configured STT provider.
-   * Returns when capture-started confirmation is received.
+   * Wraps initialization in a timeout (12s) to prevent hanging
+   * when STT provider or audio device is unavailable.
    */
   async startVoiceCapture(): Promise<void> {
     if (this.capturing) return;
 
     const prefs = getPrefs();
-    const provider = prefs.sttProvider || 'browser';
+    let provider = prefs.sttProvider;
     const language = prefs.sttLanguage || 'zh';
 
+    // Auto-detect STT provider if not configured or set to 'browser' (not available in WebKitGTK)
+    if (!provider || provider === 'browser') {
+      provider = await this.detectAvailableSttProvider();
+    }
+
     this.captureTranscripts = [];
     this.captureInterimText = '';
     this.capturing = true;
 
     try {
-      // 1. Start STT provider connection
-      const conn = await this.startSttConnection(provider, language);
-      this.sttConnection = conn;
-
-      // 2. Load audio capture module (cpal)
-      const audio = await this.loadAudioCapture();
-
-      // 3. Start cpal recording — chunks go to STT
-      const ok = await audio.startRecording(
-        (chunk: Buffer) => {
-          this.sttConnection?.send(chunk);
-        },
-        () => {
-          // Capture ended (user stop or silence detection)
-        },
+      // Wrap the whole initialization in a 12s timeout to avoid hanging
+      // when STT provider or audio device is unavailable.
+      await this.withTimeout(
+        this._initVoiceCapture(provider, language),
+        12000,
+        `Voice initialization timed out. Check that your microphone is accessible and STT provider "${provider}" is configured correctly.`,
       );
-
-      if (!ok) {
-        // Fallback: try arecord as subprocess
-        this.capturing = false;
-        throw new Error('Native audio capture unavailable');
-      }
     } catch (err) {
       this.capturing = false;
       this.sttConnection?.close();
@@ -198,6 +189,128 @@ class FriendService {
     }
   }
 
+  /**
+   * Internal voice capture initialization (STT connection + audio capture).
+   * Separated so startVoiceCapture() can wrap it with a timeout.
+   */
+  private async _initVoiceCapture(
+    provider: string,
+    language: string,
+  ): Promise<void> {
+    // 1. Start STT provider connection (with inner 8s timeout)
+    const conn = await this.startSttConnectionWithTimeout(provider, language);
+    this.sttConnection = conn;
+
+    // 2. Load audio capture module (cpal)
+    const audio = await this.loadAudioCapture();
+
+    // 3. Start cpal recording — chunks go to STT
+    const ok = await audio.startRecording(
+      (chunk: Buffer) => {
+        this.sttConnection?.send(chunk);
+      },
+      () => {
+        // Capture ended (user stop or silence detection)
+      },
+    );
+
+    if (!ok) {
+      throw new Error('Native audio capture unavailable');
+    }
+  }
+
+  /** Race a promise against a timeout */
+  private async withTimeout<T>(
+    promise: Promise<T>,
+    ms: number,
+    message: string,
+  ): Promise<T> {
+    return Promise.race([
+      promise,
+      new Promise<never>((_, reject) =>
+        setTimeout(() => reject(new Error(message)), ms),
+      ),
+    ]);
+  }
+
+  /**
+   * Auto-detect the first available STT provider.
+   * Tries: local Whisper → Anthropic Voice Stream → Doubao ASR
+   */
+  private async detectAvailableSttProvider(): Promise<string> {
+    console.log('[FriendService] detectAvailableSttProvider: checking available providers...');
+
+    // Check local Whisper first (no external API keys needed)
+    try {
+      const { checkLocalWhisperAvailable } = await import(
+        '../services/voice/whisperSTT.js'
+      );
+      const avail = await checkLocalWhisperAvailable();
+      console.log('[FriendService] detectAvailableSttProvider: local Whisper available:', avail);
+      if (avail) {
+        return 'local';
+      }
+    } catch (e) {
+      console.warn('[FriendService] detectAvailableSttProvider: local whisper check failed:', e);
+    }
+
+    // Check Anthropic Voice Stream
+    try {
+      const { isVoiceStreamAvailable } = await import(
+        '../services/voiceStreamSTT.js'
+      );
+      if (isVoiceStreamAvailable()) {
+        return 'anthropic';
+      }
+    } catch { /* skip */ }
+
+    // Check Doubao credentials file
+    try {
+      const path = await import('node:path');
+      const fs = await import('node:fs');
+      const homeDir = process.env.HOME || process.env.USERPROFILE || '';
+      const credsPath = path.join(homeDir, '.claude', 'tts', 'doubao', 'credentials.json');
+      if (fs.existsSync(credsPath)) {
+        return 'doubao';
+      }
+    } catch { /* skip */ }
+
+    throw new Error(
+      'No STT provider available. Install local Whisper:\n' +
+      '  pip install openai-whisper\n\n' +
+      'Or configure an STT provider in Friend settings (Settings → STT Provider).',
+    );
+  }
+
+  /**
+   * Start STT connection with a timeout to prevent hanging
+   * when the provider is unavailable (e.g. Python Whisper not installed).
+   */
+  private async startSttConnectionWithTimeout(
+    provider: string,
+    language: string,
+  ): Promise<{ send: (chunk: Buffer) => void; finalize: () => Promise<void>; close: () => void }> {
+    const timeoutMs = 8000;
+    const result = await Promise.race([
+      this.startSttConnection(provider, language),
+      new Promise<never>((_, reject) =>
+        setTimeout(
+          () =>
+            reject(
+              new Error(
+                `STT provider "${provider}" timed out after ${timeoutMs / 1000}s.` +
+                  (provider === 'local'
+                    ? '\nInstall local Whisper: pip install openai-whisper'
+                    : ''),
+              ),
+            ),
+          timeoutMs,
+        ),
+      ),
+    ]);
+    return result;
+  }
+
   /**
    * Stop voice capture and return the accumulated transcript.
    */
@@ -329,40 +442,15 @@ class FriendService {
     }
   }
 
-  // ── Private: Audio capture (cpal wrapper) ────────────────────────────
+  // ── Private: Audio capture (arecord/parecord subprocess) ──────────────
 
   private async loadAudioCapture(): Promise<AudioCaptureProvider> {
     if (this.audioCapture) return this.audioCapture;
 
-    // Try native cpal module first
-    try {
-      const mod = await import('audio-capture-napi').catch(() => null);
-      if (mod && typeof mod.startNativeRecording === 'function') {
-        this.audioCapture = {
-          startRecording: async (onData, onEnd) => {
-            try {
-              return mod.startNativeRecording(
-                (data: Buffer) => onData(data),
-                () => onEnd(),
-              ) as boolean;
-            } catch {
-              return false;
-            }
-          },
-          stopRecording: async () => {
-            if (mod.isNativeRecordingActive()) {
-              mod.stopNativeRecording();
-            }
-          },
-          isRecording: () => mod.isNativeRecordingActive() as boolean,
-        };
-        return this.audioCapture;
-      }
-    } catch {
-      // cpal unavailable, fall through
-    }
-
-    // Fallback: spawn arecord/parecord as subprocess
+    // Use subprocess-based capture (arecord/parecord) on all platforms.
+    // Skipping the native cpal module because its synchronous NAPI call
+    // can block the event loop if ALSA initialization hangs, and there
+    // is no way to timeout a native binding call from JS.
     const { spawn } = await import('node:child_process');
     let captureProc: import('node:child_process').ChildProcess | null = null;
 
@@ -372,7 +460,7 @@ class FriendService {
           try {
             const args = tool === 'parecord'
               ? ['--raw', '--rate=16000', '--format=s16le', '--channels=1', '--latency-msec=20']
-              : ['-r', '16000', '-f', 'S16_LE', '-c', '1', '-t', 'raw', '-q', '-'];
+              : ['-r', '16000', '-f', 'S16_LE', '-c', '1', '-t', 'raw', '-q'];
             const proc = spawn(tool, args, { stdio: ['pipe', 'pipe', 'pipe'] });
             if (proc.pid !== undefined) {
               captureProc = proc;

src/friend/server.ts

@@ -86,6 +86,7 @@ export function startFriendServer(port = 3456, host = '127.0.0.1'): ReturnType<t
   server = Bun.serve<undefined>({
     port,
     hostname: host,
+    idleTimeout: 60, // seconds — allow slow STT provider init (Python/PyTorch imports)
     async fetch(req) {
       const url = new URL(req.url);
 

src/services/voice/whisperSTT.ts

@@ -217,16 +217,23 @@ export function connectLocalWhisperStream(
   })
 }
 
+/**
+ * Fast check for local whisper availability using `find_spec` (no actual
+ * module import, avoiding the slow PyTorch/numpy import chain).
+ */
 export async function checkLocalWhisperAvailable(): Promise<boolean> {
   try {
     const python = resolvePythonPath()
     return await new Promise(resolve => {
-      const proc = spawn(python, ['-c', 'import whisper; print("ok")'], {
-        stdio: ['ignore', 'pipe', 'pipe'],
-      })
-      let out = ''
-      proc.stdout.on('data', d => { out += d.toString() })
-      proc.on('close', () => { resolve(out.trim() === 'ok') })
+      const proc = spawn(
+        python,
+        [
+          '-c',
+          'import importlib.util,sys; sys.exit(0 if importlib.util.find_spec("whisper") else 1)',
+        ],
+        { stdio: ['ignore', 'pipe', 'pipe'] },
+      )
+      proc.on('close', code => resolve(code === 0))
     })
   } catch {
     return false