feat: inter-process

架构对比

之前: 之后:
CLI TUI CLI TUI (单一进程)
└── /friend start ├── FriendService (in-process, cpal)
├── 服务器子进程 :3456 │ ├── STT via cpal
│ ├── chat-service.ts │ ├── enqueue() → 主 CLI
│ │ └── CLI SDK 子进程│ └── SSE → Tauri
│ ├── arecord 子进程 ├── 轻量 Bun.serve (in-process)
│ └── SSE └── Tauri (thin display only)
└── Tauri (getUserMedia)

src/commands/friend/friend.tsx

@@ -11,6 +11,8 @@ import {
   launchTauri,
   stopTauri,
 } from '../../friend/tauri-launcher.js'
+import { startFriendServer, stopFriendServer, getServerPort } from '../../friend/server.js'
+import { friendService } from '../../friend/FriendService.js'
 import type { LocalJSXCommandOnDone, CommandResultDisplay } from '../../types/command.js'
 
 const FRIEND_URL = 'http://127.0.0.1:3456/friend/'
@@ -29,12 +31,26 @@ export async function call(
 
   if (trimmed === 'start') {
     updatePrefs({ enabled: true })
+    // Start in-process HTTP server for friend API and SSE
+    try {
+      startFriendServer(3456, '127.0.0.1')
+    } catch (err) {
+      console.warn(`[Friend] HTTP server start failed: ${err}`)
+      console.warn('[Friend] The Tauri app may need the main server on port 3456.')
+    }
+    // FriendService runs in-process; messages enqueue into the CLI queue
+    await friendService.start().catch((err) => {
+      console.warn(`[Friend] Service start failed: ${err}`)
+    })
+    // Launch Tauri display window (thin client)
     launchTauri(logger())
     return <FriendStartView onDone={onDone} />
   }
 
   if (trimmed === 'stop') {
     updatePrefs({ enabled: false })
+    await friendService.stop().catch(() => {})
+    stopFriendServer()
     stopTauri(logger())
     return <FriendStopView onDone={onDone} />
   }

src/components/friend/frontend/App.tsx

@@ -75,6 +75,7 @@ export default function App() {
   const [screenObserve, setScreenObserve] = useState(false)
   const [screenObserveInterval, setScreenObserveInterval] = useState(60)
   const [language, setLanguage] = useState<'zh' | 'en'>(() => navigator.language.startsWith('zh') ? 'zh' : 'en')
+  const [sttProvider, setSttProvider] = useState<'browser' | 'anthropic' | 'local' | 'doubao'>('browser')
   const t = (zh: string, en: string) => language === 'en' ? en : zh
   usePassThrough(!settingsOpen && !historyOpen)
 
@@ -95,6 +96,7 @@ export default function App() {
         if (s.screenObserveInterval !== undefined) setScreenObserveInterval(s.screenObserveInterval)
         if (s.currentDance) setCurrentDance(s.currentDance)
         if (s.customDancePreset) setCustomDancePreset(s.customDancePreset)
+        if (s.sttProvider) setSttProvider(s.sttProvider)
         if (s.language) {
           setLanguage(s.language)
         } else {
@@ -369,7 +371,7 @@ export default function App() {
       <VRMScene ref={sceneRef} modelPath={modelPath} onTouch={handleTouch} onModelLoaded={uploadVrmScreenshot} />
       {!hideMood && <MoodIndicator uiAlign={uiAlign} />}
       <TextBubble onMessage={handleVrmMessageWithActivity} enabled={showText} ttsEnabled={ttsEnabled} />
-      {!hideUI && <ChatInput uiAlign={uiAlign} onHistoryOpen={() => setHistoryOpen(true)} onNewSession={clearContext} language={language} />}
+      {!hideUI && <ChatInput uiAlign={uiAlign} onHistoryOpen={() => setHistoryOpen(true)} onNewSession={clearContext} language={language} sttProvider={sttProvider} />}
       <HistoryPanel
         visible={historyOpen}
         onClose={() => setHistoryOpen(false)}
@@ -401,6 +403,8 @@ export default function App() {
         captureVrmScreenshot={() => sceneRef.current?.captureScreenshot() ?? null}
         language={language}
         onLanguageChange={(v) => { setLanguage(v); saveSettings({ language: v }) }}
+        sttProvider={sttProvider}
+        onSttProviderChange={(v) => { setSttProvider(v); saveSettings({ sttProvider: v }) }}
         currentDance={currentDance}
         onDanceChange={(id, preset) => {
           setCurrentDance(id)

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

@@ -1,12 +1,11 @@
 import { useState, useRef, useCallback, useEffect } from 'react'
 import { MessageCircle, Send, Loader, Mic, ChevronDown, History, SquarePen, Plus, Phone, PhoneOff } from 'lucide-react'
 import { FRIEND_API } from '../api'
+import { useServerStt, type SttProvider } from '../hooks/useServerStt'
 
 // Keyframes (claw-input-slide-up, claw-input-slide-down, claw-pulse) are in index.html <style>
 
-const SpeechRecognition = (window as any).SpeechRecognition || (window as any).webkitSpeechRecognition
-
-export function ChatInput({ visible = true, onActiveChange, uiAlign = 'right', onHistoryOpen, onNewSession, language = 'zh' }: { visible?: boolean; onActiveChange?: (hasText: boolean) => void; uiAlign?: 'left' | 'right'; onHistoryOpen?: () => void; onNewSession?: () => void; language?: 'zh' | 'en' }) {
+export function ChatInput({ visible = true, onActiveChange, uiAlign = 'right', onHistoryOpen, onNewSession, language = 'zh', sttProvider = 'browser' }: { visible?: boolean; onActiveChange?: (hasText: boolean) => void; uiAlign?: 'left' | 'right'; onHistoryOpen?: () => void; onNewSession?: () => void; language?: 'zh' | 'en'; sttProvider?: SttProvider }) {
   const t = (zh: string, en: string) => language === 'en' ? en : zh
   const [open, setOpen] = useState(false)
   const [text, setText] = useState('')
@@ -16,10 +15,11 @@ export function ChatInput({ visible = true, onActiveChange, uiAlign = 'right', o
   const [menuOpen, setMenuOpen] = useState(false)
   const [voiceCallActive, setVoiceCallActive] = useState(false)
   const inputRef = useRef<HTMLInputElement>(null)
-  const recognitionRef = useRef<any>(null)
   const silenceTimerRef = useRef<ReturnType<typeof setTimeout> | null>(null)
   const lastSentIndexRef = useRef(0)
   const voiceCallActiveRef = useRef(false)
+  const endVoiceCallRef = useRef<() => void>(() => {})
+  const serverStt = useServerStt()
 
   const closeBar = useCallback(() => {
     if (closing) return
@@ -48,68 +48,48 @@ export function ChatInput({ visible = true, onActiveChange, uiAlign = 'right', o
   }, [text, sending])
 
   const startRecording = useCallback(async () => {
-    // Web Speech API (Tauri native STT not available in web mode)
-    if (!SpeechRecognition) {
-      console.error('SpeechRecognition not supported')
-      return
-    }
-
-    const recognition = new SpeechRecognition()
-    recognition.lang = 'zh-CN'
-    recognition.interimResults = true
-    recognition.continuous = true
-
-    recognition.onresult = (event: any) => {
-      let transcript = ''
-      for (let i = 0; i < event.results.length; i++) {
-        transcript += event.results[i][0].transcript
-      }
-      setText(transcript)
-      onActiveChange?.(transcript.length > 0)
-    }
-
-    recognition.onerror = (event: any) => {
-      console.error('Speech recognition error:', event.error)
+    // All voice capture is server-side via cpal (no getUserMedia needed)
+    try {
+      await serverStt.startPushToTalk(sttProvider, language === 'en' ? 'en' : 'zh')
+      setRecording(true)
+      setOpen(true)
+    } catch (err) {
+      console.error('Server STT start error:', err)
       setRecording(false)
     }
+  }, [sttProvider, serverStt, language])
 
-    recognition.onend = () => {
+  const stopRecording = useCallback(async () => {
+    if (sttProvider === 'browser') {
+      // Browser STT may not be available, just stop
       setRecording(false)
-      setTimeout(() => inputRef.current?.focus(), 50)
-    }
-
-    recognition.start()
-    recognitionRef.current = recognition
-    setRecording(true)
-    setOpen(true)
-  }, [])
-
-  const stopRecording = useCallback(() => {
-    if (recognitionRef.current) {
-      recognitionRef.current.stop()
-      recognitionRef.current = null
+      return
     }
     setRecording(false)
-  }, [])
+    try {
+      const text = await serverStt.stopPushToTalk()
+      setText(text)
+      onActiveChange?.(text.length > 0)
+    } catch (err) {
+      console.error('Server STT stop error:', err)
+    }
+  }, [serverStt, sttProvider, onActiveChange])
 
-  // 鼠标移出按钮时也停止录音
   const handleMouseLeave = useCallback(() => {
     if (recording) stopRecording()
   }, [recording, stopRecording])
 
   // --- Voice Call: constants ---
-  const HARD_PUNCT = /[。！？\.\!\?]$/        // immediate send
-  const SOFT_PUNCT = /[，、；,;：:]$/           // send if long enough
-  const SOFT_PUNCT_MIN_LEN = 10               // min chars before soft punct triggers send
-  const MAX_UNSENT_LEN = 30                   // force send when accumulated text is this long
-  const SILENCE_SEND_MS = 1200                // silence fallback timeout
-  const VAD_RMS_THRESHOLD = 0.015             // RMS below this = silence
-  const VAD_SILENCE_TIMEOUT_MS = 15_000       // stop STT after 15s silence
+  const HARD_PUNCT = /[。！？\.\!\?]$/
+  const SOFT_PUNCT = /[，、；,;：:]$/
+  const SOFT_PUNCT_MIN_LEN = 10
+  const MAX_UNSENT_LEN = 30
+  const SILENCE_SEND_MS = 1200
 
   // --- Voice Call: delayed TTS interrupt ---
   const interruptTimerRef = useRef<ReturnType<typeof setTimeout> | null>(null)
   const scheduleInterrupt = useCallback(() => {
-    if (interruptTimerRef.current) return // already scheduled
+    if (interruptTimerRef.current) return
     interruptTimerRef.current = setTimeout(() => {
       interruptTimerRef.current = null
       ;(window as any).__clawInterruptAudio?.()
@@ -119,15 +99,6 @@ export function ChatInput({ visible = true, onActiveChange, uiAlign = 'right', o
     if (interruptTimerRef.current) { clearTimeout(interruptTimerRef.current); interruptTimerRef.current = null }
   }, [])
 
-  // --- Voice Call: refs ---
-  const vadStreamRef = useRef<MediaStream | null>(null)
-  const vadContextRef = useRef<AudioContext | null>(null)
-  const vadAnalyserRef = useRef<AnalyserNode | null>(null)
-  const vadRafRef = useRef<number>(0)
-  const vadSpeakingRef = useRef(false)
-  const vadSilenceTimerRef = useRef<ReturnType<typeof setTimeout> | null>(null)
-  const [vadSpeaking, setVadSpeaking] = useState(false)
-
   // --- Voice Call: send + mute capture for 3s after send ---
   const VOICE_MUTE_AFTER_SEND_MS = 2000
   const mutedUntilRef = useRef(0)
@@ -151,7 +122,6 @@ export function ChatInput({ visible = true, onActiveChange, uiAlign = 'right', o
 
   // --- Voice Call: smart sentence segmentation ---
   const handleVoiceCallResult = useCallback((fullTranscript: string, isFinal: boolean) => {
-    // Ignore STT results during post-send mute period
     if (Date.now() < mutedUntilRef.current) {
       lastSentIndexRef.current = fullTranscript.length
       return
@@ -161,14 +131,13 @@ export function ChatInput({ visible = true, onActiveChange, uiAlign = 'right', o
     setText(unsent)
     onActiveChange?.(unsent.length > 0)
 
-    // Reset silence send timer on any result
     if (silenceTimerRef.current) { clearTimeout(silenceTimerRef.current); silenceTimerRef.current = null }
 
     if (isFinal) {
       const shouldSend =
-        HARD_PUNCT.test(unsent) ||                                       // hard punctuation
-        (SOFT_PUNCT.test(unsent) && unsent.length >= SOFT_PUNCT_MIN_LEN) || // soft punct + long enough
-        unsent.length >= MAX_UNSENT_LEN                                  // word count overflow
+        HARD_PUNCT.test(unsent) ||
+        (SOFT_PUNCT.test(unsent) && unsent.length >= SOFT_PUNCT_MIN_LEN) ||
+        unsent.length >= MAX_UNSENT_LEN
 
       if (shouldSend) {
         voiceCallSend(unsent)
@@ -179,7 +148,6 @@ export function ChatInput({ visible = true, onActiveChange, uiAlign = 'right', o
       }
     }
 
-    // Silence fallback: start timer on both partial and final results
     if (unsent.trim()) {
       silenceTimerRef.current = setTimeout(() => {
         if (!voiceCallActiveRef.current) return
@@ -194,67 +162,7 @@ export function ChatInput({ visible = true, onActiveChange, uiAlign = 'right', o
     }
   }, [voiceCallSend, onActiveChange])
 
-  // --- Voice Call: VAD using AnalyserNode ---
-  const startVad = useCallback(async () => {
-    try {
-      const stream = await navigator.mediaDevices.getUserMedia({
-        audio: { echoCancellation: true, noiseSuppression: true, autoGainControl: true },
-      })
-      vadStreamRef.current = stream
-      const ctx = new AudioContext()
-      vadContextRef.current = ctx
-      const source = ctx.createMediaStreamSource(stream)
-      const analyser = ctx.createAnalyser()
-      analyser.fftSize = 512
-      source.connect(analyser)
-      vadAnalyserRef.current = analyser
-
-      const dataArray = new Float32Array(analyser.fftSize)
-      let lastSpeechTime = performance.now()
-
-      const check = () => {
-        if (!voiceCallActiveRef.current) return
-        analyser.getFloatTimeDomainData(dataArray)
-        let sum = 0
-        for (let i = 0; i < dataArray.length; i++) sum += dataArray[i] * dataArray[i]
-        const rms = Math.sqrt(sum / dataArray.length)
-
-        const speaking = rms > VAD_RMS_THRESHOLD
-        if (speaking) {
-          lastSpeechTime = performance.now()
-          if (!vadSpeakingRef.current) {
-            vadSpeakingRef.current = true
-            setVadSpeaking(true)
-            // Interrupt TTS after 1s delay when user starts speaking
-            scheduleInterrupt()
-          }
-        } else if (vadSpeakingRef.current && performance.now() - lastSpeechTime > 500) {
-          vadSpeakingRef.current = false
-          cancelInterrupt()
-          setVadSpeaking(false)
-        }
-
-        vadRafRef.current = requestAnimationFrame(check)
-      }
-      vadRafRef.current = requestAnimationFrame(check)
-    } catch (err) {
-      console.error('VAD start failed:', err)
-    }
-  }, [])
-
-  const stopVad = useCallback(() => {
-    if (vadRafRef.current) { cancelAnimationFrame(vadRafRef.current); vadRafRef.current = 0 }
-    vadStreamRef.current?.getTracks().forEach((t) => t.stop())
-    vadStreamRef.current = null
-    vadContextRef.current?.close()
-    vadContextRef.current = null
-    vadAnalyserRef.current = null
-    vadSpeakingRef.current = false
-    setVadSpeaking(false)
-    if (vadSilenceTimerRef.current) { clearTimeout(vadSilenceTimerRef.current); vadSilenceTimerRef.current = null }
-  }, [])
-
-  // --- Voice Call: start ---
+  // --- Voice Call: start (always server-side, no getUserMedia) ---
   const startVoiceCall = useCallback(async () => {
     setVoiceCallActive(true)
     voiceCallActiveRef.current = true
@@ -262,73 +170,38 @@ export function ChatInput({ visible = true, onActiveChange, uiAlign = 'right', o
     setText('')
     setOpen(true)
 
-    // Start VAD
-    await startVad()
-
-    if (!SpeechRecognition) {
-      console.error('SpeechRecognition not supported')
-      setVoiceCallActive(false)
-      voiceCallActiveRef.current = false
-      stopVad()
-      return
-    }
-
-    const startWebSTT = () => {
-      const recognition = new SpeechRecognition()
-      recognition.lang = 'zh-CN'
-      recognition.interimResults = true
-      recognition.continuous = true
-      recognitionRef.current = recognition
-
-      recognition.onresult = (event: any) => {
-        let transcript = ''
-        let latestFinalEnd = 0
-        for (let i = 0; i < event.results.length; i++) {
-          transcript += event.results[i][0].transcript
-          if (event.results[i].isFinal) latestFinalEnd = transcript.length
-        }
-        const hasFinal = latestFinalEnd > lastSentIndexRef.current
-        handleVoiceCallResult(transcript, hasFinal)
-      }
-
-      recognition.onerror = (event: any) => {
-        console.error('Voice call STT error:', event.error)
-        if (event.error === 'no-speech' || event.error === 'aborted') return
-      }
-
-      recognition.onend = () => {
-        // Auto-restart if call is still active
-        if (voiceCallActiveRef.current) {
-          lastSentIndexRef.current = 0
-          setTimeout(() => {
-            if (voiceCallActiveRef.current) startWebSTT()
-          }, 300)
-        }
-      }
-
-      recognition.start()
+    // 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) {
+            endVoiceCallRef.current()
+          }
+        },
+        language === 'en' ? 'en' : 'zh',
+      )
       setRecording(true)
+      return
     }
 
-    startWebSTT()
-  }, [handleVoiceCallResult, startVad, stopVad])
+    // 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
+  }, [handleVoiceCallResult, sttProvider, serverStt, language])
 
   // --- Voice Call: end ---
   const endVoiceCall = useCallback(() => {
     voiceCallActiveRef.current = false
     setVoiceCallActive(false)
-
-    // Stop VAD
-    stopVad()
-
-    // Stop STT
-    if (recognitionRef.current) {
-      recognitionRef.current.stop()
-      recognitionRef.current = null
-    }
+    serverStt.stopStreaming()
     setRecording(false)
 
-    // Clear timers
     if (silenceTimerRef.current) { clearTimeout(silenceTimerRef.current); silenceTimerRef.current = null }
     cancelInterrupt()
     mutedUntilRef.current = 0
@@ -336,7 +209,9 @@ export function ChatInput({ visible = true, onActiveChange, uiAlign = 'right', o
     setText('')
     setOpen(false)
     onActiveChange?.(false)
-  }, [onActiveChange, stopVad, cancelInterrupt])
+  }, [onActiveChange, cancelInterrupt, serverStt])
+
+  endVoiceCallRef.current = endVoiceCall
 
   const handleKeyDown = (e: React.KeyboardEvent) => {
     if (e.key === 'Enter' && !e.shiftKey) {
@@ -351,16 +226,14 @@ export function ChatInput({ visible = true, onActiveChange, uiAlign = 'right', o
       setText('')
       onActiveChange?.(false)
     }
-
   }
 
-  // 全局快捷键
+  // Global keyboard shortcuts
   useEffect(() => {
     const onGlobalKeyDown = (e: KeyboardEvent) => {
       if (!visible) return
       const inInput = e.target instanceof HTMLInputElement || e.target instanceof HTMLTextAreaElement
 
-      // Enter: 唤起输入框 / 聚焦输入框
       if (e.key === 'Enter' && !e.shiftKey && !inInput) {
         e.preventDefault()
         if (!open) {
@@ -370,13 +243,11 @@ export function ChatInput({ visible = true, onActiveChange, uiAlign = 'right', o
         setTimeout(() => inputRef.current?.focus(), 50)
       }
 
-      // Escape: 收起输入框
       if (e.key === 'Escape' && open && !inInput) {
         e.preventDefault()
         closeBar()
       }
 
-      // F2: 语音通话
       if (e.key === 'F2') {
         e.preventDefault()
         if (voiceCallActive) {
@@ -386,16 +257,9 @@ export function ChatInput({ visible = true, onActiveChange, uiAlign = 'right', o
         }
       }
     }
-    const onGlobalKeyUp = (_e: KeyboardEvent) => {
-      // F2 keyup no longer needed (voice call is toggle, not push-to-talk)
-    }
     window.addEventListener('keydown', onGlobalKeyDown)
-    window.addEventListener('keyup', onGlobalKeyUp)
-    return () => {
-      window.removeEventListener('keydown', onGlobalKeyDown)
-      window.removeEventListener('keyup', onGlobalKeyUp)
-    }
-  }, [open, visible, recording, voiceCallActive, startRecording, stopRecording, closeBar, startVoiceCall, endVoiceCall])
+    return () => window.removeEventListener('keydown', onGlobalKeyDown)
+  }, [open, visible, voiceCallActive, closeBar, startVoiceCall, endVoiceCall])
 
   if (!visible) return null
 
@@ -428,7 +292,6 @@ export function ChatInput({ visible = true, onActiveChange, uiAlign = 'right', o
     return (
       <div style={barStyle}>
         <div style={{ flex: 1, position: 'relative' }}>
-          {/* 左侧 + 号按钮 */}
           <button
             onClick={() => setMenuOpen((v) => !v)}
             style={{ ...inlineBtnLeft, color: menuOpen ? 'rgba(100, 160, 255, 0.9)' : 'rgba(255, 255, 255, 0.45)' }}
@@ -436,7 +299,6 @@ export function ChatInput({ visible = true, onActiveChange, uiAlign = 'right', o
           >
             <Plus size={22} />
           </button>
-          {/* 弹出菜单 */}
           {menuOpen && (
             <div style={popupMenuStyle}>
               <button onClick={() => { setMenuOpen(false); onHistoryOpen?.() }} style={popupItemStyle}>
@@ -456,22 +318,20 @@ export function ChatInput({ visible = true, onActiveChange, uiAlign = 'right', o
               paddingRight: 80,
               display: 'flex',
               alignItems: 'center',
-              borderColor: vadSpeaking ? 'rgba(255, 80, 80, 0.7)' : 'rgba(255, 80, 80, 0.25)',
+              borderColor: recording ? 'rgba(255, 80, 80, 0.7)' : 'rgba(255, 80, 80, 0.25)',
             }}
             data-no-passthrough
           >
             <span style={{ color: text ? '#fff' : 'rgba(255, 255, 255, 0.45)', fontSize: 18, overflow: 'hidden', textOverflow: 'ellipsis', whiteSpace: 'nowrap', fontFamily: '"Segoe UI", "Microsoft YaHei", sans-serif' }}>
-              {text || (vadSpeaking ? t('正在听...', 'Listening...') : t('等待说话...', 'Waiting to speak...'))}
-
+              {text || (recording ? t('正在听...', 'Listening...') : t('等待说话...', 'Waiting to speak...'))}
             </span>
           </div>
-          {/* 右侧：麦克风指示 + 挂断 */}
           <span
             style={{
               ...inlineBtnRight,
               right: 44,
-              color: vadSpeaking ? 'rgba(255, 80, 80, 0.9)' : 'rgba(80, 200, 120, 0.9)',
-              animation: vadSpeaking ? 'claw-pulse 0.8s ease-in-out infinite' : 'none',
+              color: recording ? 'rgba(255, 80, 80, 0.9)' : 'rgba(80, 200, 120, 0.9)',
+              animation: recording ? 'claw-pulse 0.8s ease-in-out infinite' : 'none',
               transition: 'color 0.2s',
               cursor: 'default',
             }}
@@ -502,7 +362,6 @@ export function ChatInput({ visible = true, onActiveChange, uiAlign = 'right', o
       }}
     >
       <div style={{ flex: 1, position: 'relative' }}>
-        {/* 左侧 + 号按钮 */}
         <button
           onClick={() => setMenuOpen((v) => !v)}
           style={{ ...inlineBtnLeft, color: menuOpen ? 'rgba(100, 160, 255, 0.9)' : 'rgba(255, 255, 255, 0.45)' }}
@@ -510,7 +369,6 @@ export function ChatInput({ visible = true, onActiveChange, uiAlign = 'right', o
         >
           <Plus size={22} />
         </button>
-        {/* 弹出菜单 */}
         {menuOpen && (
           <div style={popupMenuStyle}>
             <button onClick={() => { setMenuOpen(false); onHistoryOpen?.() }} style={popupItemStyle}>
@@ -536,7 +394,6 @@ export function ChatInput({ visible = true, onActiveChange, uiAlign = 'right', o
           style={{ ...inputStyle, paddingLeft: 48, paddingRight: 80 }}
           autoFocus
         />
-        {/* 右侧：发送/收起 */}
         <button
           onMouseDown={startRecording}
           onMouseUp={stopRecording}
@@ -669,4 +526,3 @@ const popupItemStyle: React.CSSProperties = {
   whiteSpace: 'nowrap',
   fontFamily: '"Segoe UI", "Microsoft YaHei", sans-serif',
 }
-

src/components/friend/frontend/components/SettingsPanel.tsx

@@ -12,6 +12,8 @@ interface DanceItem {
   builtin?: boolean
 }
 
+type SttProvider = 'browser' | 'anthropic' | 'local' | 'doubao'
+
 interface SettingsPanelProps {
   visible: boolean
   onClose: () => void
@@ -41,6 +43,8 @@ interface SettingsPanelProps {
   onLanguageChange: (v: 'zh' | 'en') => void
   currentDance: string
   onDanceChange: (id: string, preset?: DancePreset) => void
+  sttProvider?: SttProvider
+  onSttProviderChange?: (v: SttProvider) => void
 }
 
 type Tab = 'general' | 'voice' | 'model' | 'persona' | 'dance'
@@ -105,6 +109,7 @@ export function SettingsPanel({
   captureVrmScreenshot,
   language, onLanguageChange,
   currentDance, onDanceChange,
+  sttProvider = 'browser', onSttProviderChange,
 }: SettingsPanelProps) {
   const t = (zh: string, en: string) => language === 'en' ? en : zh
 
@@ -487,6 +492,34 @@ export function SettingsPanel({
                 </div>
               )}
 
+              <div style={{ marginTop: 8 }}>
+                <div style={labelStyle}>{t('语音识别 (STT)', 'Speech Recognition (STT)')}</div>
+                <div style={{ display: 'flex', gap: 4, flexWrap: 'wrap' }}>
+                  {(['browser', 'anthropic', 'local', 'doubao'] as const).map((p) => (
+                    <button
+                      key={p}
+                      onClick={() => onSttProviderChange?.(p)}
+                      style={{
+                        ...smallBtnStyle,
+                        flex: 1,
+                        textAlign: 'center',
+                        padding: '6px 10px',
+                        fontSize: 12,
+                        background: p === sttProvider ? 'rgba(100, 160, 255, 0.4)' : 'rgba(255, 255, 255, 0.08)',
+                        borderColor: p === sttProvider ? 'rgba(100, 160, 255, 0.6)' : 'rgba(255, 255, 255, 0.15)',
+                      }}
+                    >
+                      {{ browser: t('浏览器', 'Browser'), anthropic: 'Anthropic', local: 'Whisper', doubao: 'Doubao' }[p]}
+                    </button>
+                  ))}
+                </div>
+                <div style={{ fontSize: 11, color: 'rgba(255,255,255,0.35)', marginTop: 4 }}>
+                  {sttProvider === 'browser'
+                    ? t('使用浏览器内置语音识别（Web Speech API）', 'Use browser built-in speech recognition (Web Speech API)')
+                    : t('使用服务端语音识别，需要登录对应服务', 'Use server-side speech recognition, requires corresponding service login')}
+                </div>
+              </div>
+
               <div style={{ marginTop: 8 }}>
                 <div style={labelStyle}>{currentProvider === 'qwen' ? t('千问语音', 'Qwen Voice') : t('Edge TTS 语音', 'Edge TTS Voice')}</div>
                 <div style={{ display: 'flex', flexDirection: 'column', gap: 4, maxHeight: 200, overflowY: 'auto' }}>

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

@@ -0,0 +1,119 @@
+/**
+ * Hook for using server-side STT (Anthropic Voice Stream, Local Whisper, Doubao)
+ * in the Friend Tauri app.
+ *
+ * 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.
+ *
+ * Two modes:
+ *   - push-to-talk: POST /voice/start → capture → POST /voice/stop → get text
+ *   - streaming:    POST /voice/start → poll /voice/status → POST /voice/stop
+ */
+import { useRef, useCallback, useState } from 'react'
+
+const FRIEND_API_BASE = 'http://127.0.0.1:3456/plugins/friend'
+
+export type SttProvider = 'browser' | 'anthropic' | 'local' | 'doubao'
+
+export function useServerStt() {
+  const [connected, setConnected] = useState(false)
+
+  // ── Push-to-talk ──────────────────────────────────────────────────────
+
+  /** Start push-to-talk: tell backend to start audio capture via cpal. */
+  const startPushToTalk = useCallback(
+    async (_provider: SttProvider, _language: string): Promise<void> => {
+      const res = await fetch(`${FRIEND_API_BASE}/voice/start`, {
+        method: 'POST',
+      })
+      if (!res.ok) {
+        const err = await res.json().catch(() => ({ error: 'Unknown error' }))
+        throw new Error(err.error || 'STT start failed')
+      }
+      setConnected(true)
+    },
+    [],
+  )
+
+  /** Stop push-to-talk: stop capture and return transcript text. */
+  const stopPushToTalk = useCallback(async (): Promise<string> => {
+    const res = await fetch(`${FRIEND_API_BASE}/voice/stop`, {
+      method: 'POST',
+    })
+    setConnected(false)
+    if (!res.ok) return ''
+    const data = await res.json()
+    return data.text || ''
+  }, [])
+
+  // ── Streaming (voice call) ────────────────────────────────────────────
+
+  /**
+   * Start streaming STT for voice call mode.
+   * Transcripts arrive via polling /voice/status.
+   */
+  const startStreaming = useCallback(
+    (
+      _provider: SttProvider,
+      onTranscript: (text: string, isFinal: boolean) => void,
+      onError: (err: string) => void,
+      _language = 'zh',
+    ) => {
+      // Start capture
+      fetch(`${FRIEND_API_BASE}/voice/start`, { method: 'POST' })
+        .then((res) => {
+          if (!res.ok) throw new Error('STT start failed')
+          setConnected(true)
+
+          // Poll for interim results every 500ms
+          const pollId = setInterval(async () => {
+            try {
+              const statusRes = await fetch(`${FRIEND_API_BASE}/voice/status`, {
+                method: 'POST',
+              })
+              if (!statusRes.ok) return
+              const status = await statusRes.json()
+              if (status.interimText) {
+                onTranscript(status.interimText, false)
+              }
+            } catch {
+              // poll failed, ignore
+            }
+          }, 500)
+
+          // Store poll ID for cleanup
+          ;(window as any).__friendSttPollId = pollId
+        })
+        .catch((err) => {
+          onError(err.message)
+        })
+    },
+    [],
+  )
+
+  /** Stop streaming STT. */
+  const stopStreaming = useCallback(() => {
+    // Stop polling
+    const pollId = (window as any).__friendSttPollId
+    if (pollId) {
+      clearInterval(pollId)
+      delete (window as any).__friendSttPollId
+    }
+
+    // Stop capture
+    fetch(`${FRIEND_API_BASE}/voice/stop`, { method: 'POST' })
+      .catch(() => {})
+      .finally(() => {
+        setConnected(false)
+      })
+  }, [])
+
+  return {
+    connected,
+    startPushToTalk,
+    stopPushToTalk,
+    startStreaming,
+    stopStreaming,
+  }
+}

src/friend/FriendService.ts

@@ -0,0 +1,442 @@
+/**
+ * FriendService — in-process VRM companion brain service.
+ *
+ * Mirror of FeishuService pattern:
+ *   - Singleton, runs in the main CLI process
+ *   - subscribe()/subscribeToInbound() for React external store sync
+ *   - enqueue() with origin tracking for message submission
+ *   - In-process audio capture via cpal (src/services/voice.ts)
+ *   - SSE broadcast for VRM display commands
+ *
+ * Eliminates the need for:
+ *   - A separate background server subprocess (port 3456)
+ *   - A CLI SDK subprocess (conversationService.startSession)
+ *   - Server-side arecord/parecord audio capture
+ */
+
+import { broadcastToVrm, type VrmBroadcastPayload } from './sse.js';
+import { getPrefs } from './prefs.js';
+import { stripForTts } from './text-utils.js';
+import { edgeTts, qwenTts, registerAudioFile } from './tts.js';
+import { splitSentences } from './text-utils.js';
+
+// ── Types ──────────────────────────────────────────────────────────────
+
+export type FriendServiceState = {
+  status: 'stopped' | 'starting' | 'running' | 'error';
+  lastError?: string;
+  /** Number of active SSE display clients */
+  displayClientCount?: number;
+  /** Current capture status (for voice call interim polling) */
+  captureStatus?: { capturing: boolean; interimText?: string };
+};
+
+type Listener = () => void;
+
+/** Inbound event for bridge hook consumption */
+export type FriendInboundEvent = {
+  text: string;
+};
+
+type InboundListener = (event: FriendInboundEvent) => void;
+
+// ── Audio capture types (cpal wrapper) ─────────────────────────────────
+
+type AudioCaptureProvider = {
+  startRecording(
+    onData: (chunk: Buffer) => void,
+    onEnd: () => void,
+  ): Promise<boolean>;
+  stopRecording(): Promise<void>;
+  isRecording(): boolean;
+};
+
+// ── Service implementation ─────────────────────────────────────────────
+
+class FriendService {
+  private listeners = new Set<Listener>();
+  private inboundListeners = new Set<InboundListener>();
+  private state: FriendServiceState = { status: 'stopped' };
+  /** Audio capture in progress? */
+  private capturing = false;
+  /** Accumulated STT text chunks during capture */
+  private captureTranscripts: string[] = [];
+  /** Interim (non-final) text during active capture */
+  private captureInterimText = '';
+  /** Resolver for the current stopVoiceCapture() call */
+  private captureResolver: ((text: string) => void) | null = null;
+  /** Lazy-loaded cpal audio capture module */
+  private audioCapture: AudioCaptureProvider | null = null;
+  /** Active STT connection (Anthropic/Doubao/Whisper) during capture */
+  private sttConnection: { send: (chunk: Buffer) => void; finalize: () => Promise<void>; close: () => void } | null = null;
+
+  // ── React sync external store interface ──────────────────────────────
+
+  subscribe(listener: Listener): () => void {
+    this.listeners.add(listener);
+    return () => this.listeners.delete(listener);
+  }
+
+  subscribeToInbound(listener: InboundListener): () => void {
+    this.inboundListeners.add(listener);
+    return () => this.inboundListeners.delete(listener);
+  }
+
+  getStateSnapshot(): FriendServiceState {
+    return this.state;
+  }
+
+  // ── Lifecycle ────────────────────────────────────────────────────────
+
+  async start(): Promise<void> {
+    if (this.state.status === 'running') return;
+
+    this.setState({ status: 'starting', lastError: undefined });
+
+    try {
+      // Pre-warm cpal audio module (loaded on first use)
+      // The voice service lazy-loads audio-capture-napi, so the first
+      // capture will incur the ~1s dlopen penalty regardless.
+
+      this.setState({ status: 'running' });
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      this.setState({ status: 'error', lastError: msg });
+      throw err;
+    }
+  }
+
+  async stop(): Promise<void> {
+    // Stop any active capture
+    if (this.capturing) {
+      await this.stopVoiceCapture().catch(() => {});
+    }
+
+    this.audioCapture = null;
+    this.sttConnection = null;
+
+    if (this.state.status !== 'stopped') {
+      this.setState({ status: 'stopped' });
+    }
+  }
+
+  // ── Text relay via messageQueueManager.enqueue() ─────────────────────
+
+  /**
+   * Send text through the main CLI conversation.
+   * Mirrors FeishuService's enqueue() pattern with origin tracking.
+   */
+  sendText(text: string): void {
+    const trimmed = text.trim();
+    if (!trimmed) return;
+
+    // Notify inbound listeners (bridge hook uses this for turn tracking)
+    for (const listener of this.inboundListeners) {
+      listener({ text: trimmed });
+    }
+
+    // Dynamically import enqueue to avoid circular deps
+    import('../utils/messageQueueManager.js').then(({ enqueue }) => {
+      enqueue({
+        value: trimmed,
+        mode: 'prompt',
+        skipSlashCommands: true,
+        bridgeOrigin: true,
+        origin: { kind: 'channel', server: 'friend' },
+      });
+    }).catch((err) => {
+      console.error('[FriendService] enqueue failed:', err);
+    });
+  }
+
+  // ── Voice capture ────────────────────────────────────────────────────
+
+  /**
+   * Start in-process voice capture using cpal.
+   * Audio is forwarded to the configured STT provider.
+   * Returns when capture-started confirmation is received.
+   */
+  async startVoiceCapture(): Promise<void> {
+    if (this.capturing) return;
+
+    const prefs = getPrefs();
+    const provider = prefs.sttProvider || 'browser';
+    const language = prefs.sttLanguage || 'zh';
+
+    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)
+        },
+      );
+
+      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();
+      this.sttConnection = null;
+      throw err;
+    }
+  }
+
+  /**
+   * Stop voice capture and return the accumulated transcript.
+   */
+  async stopVoiceCapture(): Promise<string> {
+    if (!this.capturing) return '';
+
+    this.capturing = false;
+
+    // Stop cpal recording
+    if (this.audioCapture) {
+      await this.audioCapture.stopRecording().catch(() => {});
+    }
+
+    // Finalize STT connection
+    const conn = this.sttConnection;
+    this.sttConnection = null;
+
+    if (conn) {
+      try {
+        await conn.finalize();
+        conn.close();
+      } catch {
+        // ignore finalization errors
+      }
+    }
+
+    const transcript = this.captureTranscripts.join('');
+    this.captureTranscripts = [];
+    this.captureInterimText = '';
+    this.setState({ captureStatus: { capturing: false } });
+    return transcript;
+  }
+
+  /**
+   * Get current capture status (for voice call interim polling).
+   */
+  getCaptureStatus(): { capturing: boolean; interimText?: string } {
+    return this.state.captureStatus ?? { capturing: false };
+  }
+
+  // ── Response broadcast (called by useFriendBridge) ───────────────────
+
+  /**
+   * Broadcast AI response to the VRM display layer via SSE.
+   * Generates TTS audio for completed sentences and sends
+   * emotion/action commands alongside text.
+   */
+  async broadcastResponse(text: string): Promise<void> {
+    if (!text.trim()) return;
+
+    const prefs = getPrefs();
+
+    // Send the text — the frontend TextBubble splits and displays it
+    broadcastToVrm({ text });
+
+    // Generate TTS for the full response if enabled
+    if (prefs.ttsEnabled) {
+      try {
+        const audioUrl = await this.generateTts(text);
+        if (audioUrl) {
+          broadcastToVrm({ audioUrl, sendFirstTts: true });
+        }
+      } catch (err) {
+        console.warn('[FriendService] TTS generation failed:', err);
+      }
+    }
+
+    // Signal reply done
+    broadcastToVrm({ replyDone: true });
+  }
+
+  /**
+   * Broadcast VRM emotion/action command.
+   */
+  broadcastVrm(payload: VrmBroadcastPayload): void {
+    broadcastToVrm(payload);
+  }
+
+  // ── Private: STT connection factory ──────────────────────────────────
+
+  private async startSttConnection(
+    provider: string,
+    language: string,
+  ): Promise<{ send: (chunk: Buffer) => void; finalize: () => Promise<void>; close: () => void }> {
+    const callbacks = {
+      onTranscript: (text: string, isFinal: boolean) => {
+        if (isFinal) {
+          this.captureTranscripts.push(text);
+          this.captureInterimText = '';
+        } else {
+          this.captureInterimText = text;
+        }
+        // Update state for status polling
+        this.setState({
+          captureStatus: { capturing: true, interimText: this.captureInterimText },
+        });
+      },
+      onError: (_error: string) => {},
+      onClose: () => {},
+      onReady: (_conn: any) => {},
+    };
+
+    switch (provider) {
+      case 'anthropic': {
+        const { connectVoiceStream, isVoiceStreamAvailable } = await import(
+          '../services/voiceStreamSTT.js'
+        );
+        if (!isVoiceStreamAvailable()) {
+          throw new Error('Anthropic Voice Stream not available');
+        }
+        return await connectVoiceStream(callbacks, { language, keyterms: ['code', 'versperclaw'] });
+      }
+
+      case 'local': {
+        const { connectLocalWhisperStream, preloadWhisperModel } = await import(
+          '../services/voice/whisperSTT.js'
+        );
+        await preloadWhisperModel({ language });
+        return await connectLocalWhisperStream(callbacks, { language });
+      }
+
+      case 'doubao': {
+        const { connectDoubaoStream } = await import('../services/doubaoSTT.js');
+        return await connectDoubaoStream(callbacks, { language: language || 'zh' });
+      }
+
+      default:
+        throw new Error(`Unknown STT provider: ${provider}`);
+    }
+  }
+
+  // ── Private: Audio capture (cpal wrapper) ────────────────────────────
+
+  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
+    const { spawn } = await import('node:child_process');
+    let captureProc: import('node:child_process').ChildProcess | null = null;
+
+    this.audioCapture = {
+      startRecording: async (onData, _onEnd) => {
+        for (const tool of ['parecord', 'arecord']) {
+          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', '-'];
+            const proc = spawn(tool, args, { stdio: ['pipe', 'pipe', 'pipe'] });
+            if (proc.pid !== undefined) {
+              captureProc = proc;
+              proc.stdout?.on('data', onData);
+              proc.on('exit', () => { captureProc = null; });
+              return true;
+            }
+          } catch {
+            continue;
+          }
+        }
+        return false;
+      },
+      stopRecording: async () => {
+        if (captureProc) {
+          captureProc.kill('SIGTERM');
+          setTimeout(() => {
+            try { captureProc?.kill('SIGKILL'); } catch {}
+          }, 2000);
+          captureProc = null;
+        }
+      },
+      isRecording: () => captureProc !== null,
+    };
+
+    return this.audioCapture;
+  }
+
+  // ── Private: TTS generation ──────────────────────────────────────────
+
+  private async generateTts(text: string): Promise<string | undefined> {
+    const prefs = getPrefs();
+    if (!prefs.ttsEnabled) return undefined;
+
+    const cleanText = stripForTts(text);
+    if (!cleanText) return undefined;
+
+    let result: { success: boolean; audioPath?: string; error?: string };
+    if (prefs.provider === 'qwen' && prefs.qwenKey) {
+      result = await qwenTts({
+        text: cleanText,
+        apiKey: prefs.qwenKey,
+        voice: prefs.voice,
+        model: prefs.qwenModel,
+        language: prefs.language,
+      });
+    } else {
+      result = await edgeTts({ text: cleanText, voice: prefs.voice });
+    }
+
+    if (result.success && result.audioPath) {
+      return registerAudioFile(result.audioPath);
+    }
+
+    return undefined;
+  }
+
+  // ── Private: state management ────────────────────────────────────────
+
+  private setState(next: Partial<FriendServiceState>): void {
+    this.state = { ...this.state, ...next };
+    for (const listener of this.listeners) listener();
+  }
+}
+
+// Singleton
+export const friendService = new FriendService();

src/friend/chat-service.ts

@@ -1,360 +0,0 @@
-/**
- * FriendChatService — LLM conversation dispatch for Friend VRM desktop pet.
- *
- * Manages a dedicated VersperClaw CLI subprocess session (via ConversationService),
- * captures streaming SDK output, and broadcasts text/TTS through SSE to the
- * VRM frontend using the StreamingTtsTracker pattern.
- */
-import path from 'node:path';
-import { mkdirSync } from 'node:fs';
-import { conversationService } from '../server/services/conversationService.js';
-import { broadcastToVrm, type VrmBroadcastPayload } from './sse.js';
-import { edgeTts, qwenTts, registerAudioFile } from './tts.js';
-import { stripForTts, splitSentences } from './text-utils.js';
-import { getPrefs } from './prefs.js';
-
-const SESSION_ID = 'friend';
-
-// ── StreamingTtsTracker ──────────────────────────────────────────────────────
-//
-// Adapted from friend/src/channel.ts (OpenClaw version). Receives accumulated
-// text, detects sentence boundaries, generates TTS for completed sentences, and
-// broadcasts via the VRM SSE pipeline in the correct order.
-
-class StreamingTtsTracker {
-  private sentencesSent = 0;
-  private audioDispatched = 0;
-  private accumulatedText = '';
-  private resolveFirstSent!: () => void;
-  private firstSentPromise = new Promise<void>((r) => { this.resolveFirstSent = r; });
-  private finalized = false;
-
-  private static readonly FIRST_TTS_TIMEOUT_MS = 5000;
-  private static readonly SENTENCE_END_RE = /[。！？；!?;~]$/;
-
-  constructor(
-    private onSendFirstTts: (text: string, audioUrl: string | undefined) => void,
-    private onAppendSentence: (text: string, audioUrl: string | undefined, index: number) => void,
-    private onReplyDone: () => void,
-  ) {}
-
-  /** Feed accumulated streaming text. May be called many times as text arrives. */
-  processPartial(partialText: string): void {
-    if (this.finalized) return;
-    this.accumulatedText = partialText;
-    if (this.audioDispatched > 0) return;
-
-    const sentences = splitSentences(partialText);
-    if (sentences.length === 0) return;
-
-    // Consider the first N-1 sentences as complete if the last sentence is
-    // still incomplete (no sentence-ending punctuation).
-    const lastComplete =
-      sentences.length > 1
-        ? sentences.length - 1
-        : StreamingTtsTracker.SENTENCE_END_RE.test(sentences[0])
-          ? 1
-          : 0;
-
-    if (lastComplete === 0) return;
-
-    const first = sentences[0];
-    const cleaned = stripForTts(first);
-    if (!cleaned) return;
-
-    this.audioDispatched++;
-    this.dispatchFirstTts(cleaned);
-  }
-
-  /** Signal that the full text is available (streaming ended). */
-  processFinal(): void {
-    if (this.finalized) return;
-    this.finalized = true;
-
-    const sentences = splitSentences(this.accumulatedText);
-    const newSentences = sentences.slice(this.sentencesSent);
-    this.sentencesSent = sentences.length;
-
-    const ttsSentences = newSentences.filter((s) => stripForTts(s).length > 0);
-
-    // Edge case: no sentences were dispatched during streaming
-    if (this.audioDispatched === 0) {
-      if (ttsSentences.length === 0) {
-        // No TTS-worthy content — still show the raw text
-        this.onSendFirstTts(this.accumulatedText || '', undefined);
-        this.resolveFirstSent();
-        this.firstSentPromise.then(() => this.onReplyDone());
-        return;
-      }
-      this.audioDispatched++;
-      this.dispatchFirstTts(ttsSentences[0]);
-      ttsSentences.shift();
-    }
-
-    if (ttsSentences.length === 0) {
-      this.firstSentPromise.then(() => this.onReplyDone());
-      return;
-    }
-
-    // Generate TTS for all remaining sentences concurrently,
-    // but deliver them sequentially (ordered via promise chain).
-    const ttsPromises = ttsSentences.map((s) => this.generateTtsUrl(s));
-    let chain = this.firstSentPromise;
-    for (let i = 0; i < ttsSentences.length; i++) {
-      const sentence = ttsSentences[i];
-      const idx = this.sentencesSent - ttsSentences.length + i;
-      const p = ttsPromises[i];
-      chain = chain.then(() => p).then((audioUrl) => {
-        this.onAppendSentence(sentence, audioUrl, idx);
-      });
-    }
-    chain.then(() => this.onReplyDone());
-  }
-
-  private async dispatchFirstTts(sentence: string): Promise<void> {
-    const ttsPromise = this.generateTtsUrl(sentence);
-    const audioUrl = await Promise.race([
-      ttsPromise,
-      new Promise<undefined>((r) =>
-        setTimeout(r, StreamingTtsTracker.FIRST_TTS_TIMEOUT_MS),
-      ),
-    ]);
-    this.onSendFirstTts(sentence, audioUrl);
-    this.resolveFirstSent();
-  }
-
-  private async generateTtsUrl(text: string): Promise<string | undefined> {
-    try {
-      const prefs = getPrefs();
-      if (!prefs.ttsEnabled) return undefined;
-
-      const cleanText = stripForTts(text);
-      if (!cleanText) return undefined;
-
-      let result: { success: boolean; audioPath?: string; error?: string };
-      if (prefs.provider === 'qwen' && prefs.qwenKey) {
-        result = await qwenTts({
-          text: cleanText,
-          apiKey: prefs.qwenKey,
-          voice: prefs.voice,
-          model: prefs.qwenModel,
-          language: prefs.language,
-        });
-      } else {
-        result = await edgeTts({ text: cleanText, voice: prefs.voice });
-      }
-
-      if (result.success && result.audioPath) {
-        return registerAudioFile(result.audioPath);
-      }
-      return undefined;
-    } catch {
-      return undefined;
-    }
-  }
-}
-
-// ── FriendChatService ────────────────────────────────────────────────────────
-
-export class FriendChatService {
-  private sessionStarted = false;
-  private outputRegistered = false;
-
-  /** Accumulated text for the current conversational turn. */
-  private accumulatedText = '';
-  /** Non-null between sendMessage() and the conclusion of that turn. */
-  private currentTracker: StreamingTtsTracker | null = null;
-  /** True while the current user message is being processed by the CLI. */
-  private turnActive = false;
-  /** True if at least one text_delta was received this turn. */
-  private hasTextContent = false;
-
-  private replyDoneTimer: ReturnType<typeof setTimeout> | null = null;
-  private readonly REPLY_DONE_DELAY_MS = 1500;
-
-  // ── Lifecycle ────────────────────────────────────────────────────────────
-
-  /**
-   * Ensure a ConversationService session exists for Friend.
-   * Safe to call multiple times — only starts once.
-   */
-  async ensureSession(serverHost: string, serverPort: number): Promise<void> {
-    if (this.sessionStarted) return;
-
-    const homeDir = process.env.HOME || process.env.USERPROFILE || '';
-    const workDir = path.join(homeDir, '.config', 'VersperClaw', 'friend');
-    mkdirSync(workDir, { recursive: true });
-
-    const sdkUrl =
-      `ws://${serverHost}:${serverPort}/sdk/${SESSION_ID}` +
-      `?token=${crypto.randomUUID()}`;
-
-    if (!conversationService.hasSession(SESSION_ID)) {
-      try {
-        await conversationService.startSession(SESSION_ID, workDir, sdkUrl);
-      } catch (err) {
-        console.warn(`[FriendChat] session start failed: ${err}`);
-        throw err;
-      }
-    }
-
-    this.sessionStarted = true;
-    this.registerOutputCallback();
-  }
-
-  /** Tear down the Friend session. */
-  stop(): void {
-    if (this.replyDoneTimer) clearTimeout(this.replyDoneTimer);
-    conversationService.stopSession(SESSION_ID);
-    this.sessionStarted = false;
-    this.turnActive = false;
-  }
-
-  // ── Send ─────────────────────────────────────────────────────────────────
-
-  /**
-   * Send a chat message through the CLI subprocess. Returns immediately;
-   * the response is streamed asynchronously via SSE.
-   */
-  sendMessage(text: string): void {
-    // Reset per-turn state
-    this.accumulatedText = '';
-    this.hasTextContent = false;
-    this.turnActive = true;
-
-    // Show thinking emotion immediately
-    broadcastToVrm({ emotion: 'think', emotionIntensity: 0.7 });
-
-    // Create a fresh tracker for this turn
-    this.currentTracker = new StreamingTtsTracker(
-      (t, audioUrl) => {
-        const payload: VrmBroadcastPayload = { text: t, sendFirstTts: true };
-        if (audioUrl) {
-          payload.audioUrl = audioUrl;
-          payload.audioIndex = 0;
-        }
-        broadcastToVrm(payload);
-      },
-      (t, audioUrl, index) => {
-        const payload: VrmBroadcastPayload = { text: t, appendText: true, audioIndex: index };
-        if (audioUrl) payload.audioUrl = audioUrl;
-        broadcastToVrm(payload);
-      },
-      () => {
-        broadcastToVrm({ replyDone: true });
-        this.turnActive = false;
-      },
-    );
-
-    const sent = conversationService.sendMessage(SESSION_ID, text);
-    if (!sent) {
-      console.warn('[FriendChat] CLI session not running, cannot send message');
-      broadcastToVrm({ text: 'The companion is not available right now.' });
-      broadcastToVrm({ replyDone: true });
-      this.turnActive = false;
-    }
-  }
-
-  /** Send a /new command to clear conversation context. */
-  clearContext(): void {
-    this.accumulatedText = '';
-    this.hasTextContent = false;
-    conversationService.sendMessage(SESSION_ID, '/new');
-  }
-
-  /** Send a memo message (user note appended without LLM reply). */
-  sendMemo(text: string): void {
-    // Append as a user message without expecting a reply.
-    // Use the conversation message format.
-    conversationService.sendMessage(SESSION_ID, text);
-  }
-
-  // ── SDK output handling ──────────────────────────────────────────���───────
-
-  private registerOutputCallback(): void {
-    if (this.outputRegistered) return;
-    this.outputRegistered = true;
-
-    // Clear any stale callbacks first — prevents accumulation on restart.
-    conversationService.clearOutputCallbacks(SESSION_ID);
-    conversationService.onOutput(SESSION_ID, (msg: any) => {
-      this.handleSdkMessage(msg);
-    });
-  }
-
-  private handleSdkMessage(msg: any): void {
-    // ── Auto-grant all tool permissions for Friend ──────────────────────
-    if (msg?.type === 'control_request' && msg.request?.subtype === 'can_use_tool') {
-      conversationService.respondToPermission(msg.request_id, true, 'always');
-      return;
-    }
-
-    // ── Streaming text ──────────────────────────────────────────────────
-    if (msg.type === 'stream_event') {
-      const event = msg.event;
-      if (!event) return;
-
-      // Accumulate text deltas and feed to the tracker
-      if (event.type === 'content_block_delta' && event.delta?.type === 'text_delta' && event.delta.text) {
-        this.accumulatedText += event.delta.text;
-        this.hasTextContent = true;
-        this.currentTracker?.processPartial(this.accumulatedText);
-        this.debounceReplyDone();
-        return;
-      }
-
-      // An assistant message section ended — if we have accumulated text,
-      // signal the tracker to process remaining sentences.
-      if (event.type === 'message_stop' && this.hasTextContent) {
-        this.currentTracker?.processFinal();
-        return;
-      }
-
-      return;
-    }
-
-    // ── Complete assistant message (fallback when no streaming) ─────────
-    if (msg.type === 'assistant' && msg.message?.content && !this.hasTextContent) {
-      for (const block of msg.message.content) {
-        if (block.type === 'text' && block.text) {
-          this.accumulatedText = block.text;
-          this.hasTextContent = true;
-          this.currentTracker?.processFinal();
-          break;
-        }
-      }
-      return;
-    }
-
-    // ── result / error handling ─────────────────────────────────────────
-    if (msg.type === 'result' && msg.is_error) {
-      console.warn(`[FriendChat] SDK error: ${msg.result ?? 'unknown error'}`);
-      if (this.turnActive) {
-        broadcastToVrm({
-          text: `Error: ${msg.result ?? 'Something went wrong'}`,
-          appendText: true,
-          audioIndex: 99,
-        });
-        broadcastToVrm({ replyDone: true });
-        this.turnActive = false;
-      }
-    }
-  }
-
-  /**
-   * Debounce `replyDone` broadcast. Each new text delta resets the timer.
-   * This prevents premature turn completion when the CLI is generating
-   * tool-related follow-up text.
-   */
-  private debounceReplyDone(): void {
-    if (this.replyDoneTimer) clearTimeout(this.replyDoneTimer);
-    this.replyDoneTimer = setTimeout(() => {
-      if (this.currentTracker && this.hasTextContent) {
-        this.currentTracker.processFinal();
-      }
-    }, this.REPLY_DONE_DELAY_MS);
-  }
-}
-
-// Singleton
-export const friendChatService = new FriendChatService();

src/friend/prefs.ts

@@ -22,6 +22,10 @@ export interface FriendPrefs {
   language?: 'zh' | 'en';
   currentDance?: string;
   hideMood?: boolean;
+  /** STT provider: browser | anthropic | local | doubao */
+  sttProvider?: 'browser' | 'anthropic' | 'local' | 'doubao';
+  /** STT language override (e.g. 'en', 'zh', 'ja') */
+  sttLanguage?: string;
 }
 
 const homeDir = process.env.HOME || process.env.USERPROFILE || '';

src/friend/server.ts

@@ -0,0 +1,151 @@
+/**
+ * Friend HTTP server — lightweight Bun.serve for VRM frontend.
+ *
+ * Runs in the main CLI process alongside the Ink TUI.
+ * Serves the friend frontend static files, API routes, and SSE.
+ *
+ * Architecture:
+ *   - No WebSocket (frontend uses SSE for server→client, HTTP for client→server)
+ *   - No separate CLI SDK session (uses FriendService → enqueue() → main CLI)
+ *   - No arecord/parecord subprocess (uses cpal in-process)
+ */
+
+import { createSseResponse } from './sse.js';
+import { handleFriendStaticRequest } from '../server/staticFriend.js';
+import { handleFriendApi } from '../server/api/friend.js';
+
+let server: ReturnType<typeof Bun.serve> | null = null;
+let serverPort = 3456;
+
+export function getServerPort(): number {
+  return serverPort;
+}
+
+/**
+ * Try to kill any existing process listening on the given port.
+ * Returns true if the port became free.
+ */
+function freePort(port: number): boolean {
+  try {
+    // Find PID on the port
+    const ss = Bun.spawnSync(['ss', '-tlnp', 'sport', `= :${port}`]);
+    const out = ss.stdout.toString();
+    const pidMatch = out.match(/pid=(\d+)/);
+    if (!pidMatch) return true; // port already free
+
+    const pid = parseInt(pidMatch[1]!, 10);
+    if (pid === process.pid) return true; // we own it
+
+    // Only kill bun/VersperClaw processes — don't touch unknown services
+    const proc = Bun.spawnSync(['ps', '-p', String(pid), '-o', 'comm=']);
+    const comm = proc.stdout.toString().trim();
+    if (!comm) return false; // process doesn't exist
+    const baseName = comm.split('/').pop() || comm;
+    if (baseName !== 'bun' && baseName !== 'VersperClaw' && !baseName.startsWith('claude-') && !baseName.includes('node')) {
+      console.warn(`[FriendServer] Port ${port} is occupied by non-VersperClaw process: ${comm}`);
+      return false;
+    }
+
+    // Send SIGTERM politely
+    process.kill(pid, 'SIGTERM');
+    // Wait up to 3s for it to die
+    for (let i = 0; i < 30; i++) {
+      Bun.sleepSync(100);
+      try { process.kill(pid, 0); } catch { return true; } // dead
+    }
+    // Force kill
+    try { process.kill(pid, 'SIGKILL'); } catch { /* */ }
+    Bun.sleepSync(200);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Start the friend HTTP server in-process.
+ * Safe to call multiple times — no-op if already running.
+ * If the port is already in use, attempts to free it first.
+ */
+export function startFriendServer(port = 3456, host = '127.0.0.1'): ReturnType<typeof Bun.serve> {
+  if (server) return server;
+
+  serverPort = port;
+
+  // If port is in use, try to free it
+  const check = Bun.spawnSync(['ss', '-tlnp', 'sport', `= :${port}`]);
+  if (check.stdout.toString().includes('LISTEN')) {
+    console.log(`[FriendServer] Port ${port} is in use, attempting to free it...`);
+    if (!freePort(port)) {
+      console.warn(`[FriendServer] Could not free port ${port}. Please stop the existing server manually.`);
+      throw new Error(`Port ${port} is already in use`);
+    }
+    console.log(`[FriendServer] Port ${port} freed successfully.`);
+  }
+
+  server = Bun.serve<undefined>({
+    port,
+    hostname: host,
+    async fetch(req) {
+      const url = new URL(req.url);
+
+      // CORS preflight
+      if (req.method === 'OPTIONS') {
+        return new Response(null, {
+          status: 204,
+          headers: {
+            'Access-Control-Allow-Origin': '*',
+            'Access-Control-Allow-Methods': 'GET, POST, OPTIONS',
+            'Access-Control-Allow-Headers': 'Content-Type',
+          },
+        });
+      }
+
+      // SSE events (GET /plugins/friend/events)
+      if (url.pathname === '/plugins/friend/events' && req.method === 'GET') {
+        return createSseResponse();
+      }
+
+      // Friend API routes (/plugins/friend/*)
+      if (url.pathname.startsWith('/plugins/friend/')) {
+        return handleFriendApi(req, url);
+      }
+
+      // WebSocket upgrade — not needed for friend (uses SSE + HTTP)
+      // but handle gracefully
+      if (req.headers.get('upgrade')?.toLowerCase() === 'websocket') {
+        return new Response('WebSocket not supported via friend server', { status: 426 });
+      }
+
+      // Static files (/friend/*)
+      if (url.pathname.startsWith('/friend/') || url.pathname === '/friend') {
+        const staticResponse = await handleFriendStaticRequest(req, url);
+        if (staticResponse) return staticResponse;
+      }
+
+      return new Response('Not Found', { status: 404 });
+    },
+    error(err) {
+      console.error('[FriendServer] Error:', err);
+      return new Response('Internal Server Error', { status: 500 });
+    },
+  });
+
+  console.log(`[FriendServer] Listening on http://${host}:${port}`);
+  return server;
+}
+
+/**
+ * Stop the friend HTTP server.
+ */
+export function stopFriendServer(): void {
+  if (server) {
+    try {
+      server.stop();
+      server = null;
+      console.log('[FriendServer] Stopped');
+    } catch (err) {
+      console.error('[FriendServer] Error stopping:', err);
+    }
+  }
+}

src/friend/stt-service.ts

@@ -0,0 +1,164 @@
+/**
+ * STT file transcription for Friend.
+ *
+ * Provides file-based transcription using /voice STT providers
+ * (Anthropic Voice Stream, Local Whisper, Doubao).
+ *
+ * Streaming/in-process capture is handled by FriendService.ts
+ * (which uses cpal for native in-process audio capture).
+ */
+
+import type { FriendPrefs } from './prefs.js';
+import {
+  connectVoiceStream,
+  isVoiceStreamAvailable,
+} from '../services/voiceStreamSTT.js';
+import {
+  connectLocalWhisperStream,
+  preloadWhisperModel,
+} from '../services/voice/whisperSTT.js';
+
+// ── Types ──────────────────────────────────────────────────────────────
+
+type SttProvider = 'browser' | 'anthropic' | 'local' | 'doubao';
+
+// ── STT connection factory ─────────────────────────────────────────────
+
+async function startSttConnection(
+  provider: SttProvider,
+  language: string | undefined,
+  callbacks: {
+    onTranscript(text: string, isFinal: boolean): void;
+    onError(error: string, opts?: { fatal?: boolean }): void;
+    onClose(): void;
+    onReady(conn: any): void;
+  },
+) {
+  switch (provider) {
+    case 'anthropic': {
+      if (!isVoiceStreamAvailable()) {
+        callbacks.onError('Anthropic Voice Stream not available (not logged in?)');
+        return null;
+      }
+      const conn = await connectVoiceStream(callbacks, {
+        language: language || 'en',
+        keyterms: ['code', 'versperclaw'],
+      });
+      return conn;
+    }
+
+    case 'local': {
+      await preloadWhisperModel({ language: language || 'en' });
+      const conn = await connectLocalWhisperStream(callbacks, {
+        language: language || 'en',
+      });
+      return conn;
+    }
+
+    case 'doubao': {
+      try {
+        const { connectDoubaoStream } = await import(
+          '../services/doubaoSTT.js'
+        );
+        const conn = await connectDoubaoStream(callbacks, {
+          language: language || 'zh',
+        });
+        return conn;
+      } catch (err: any) {
+        callbacks.onError(`Doubao STT import failed: ${err?.message}`);
+        return null;
+      }
+    }
+
+    default:
+      callbacks.onError(`Unknown STT provider: ${provider}`);
+      return null;
+  }
+}
+
+// ── File-based transcription (REST) ────────────────────────────────────
+
+export async function transcribeAudioFile(
+  wavBuffer: Buffer,
+  prefs: FriendPrefs,
+): Promise<{ text: string }> {
+  const provider = (prefs.sttProvider || 'browser') as SttProvider;
+  const language = prefs.sttLanguage;
+
+  switch (provider) {
+    case 'local': {
+      const { mkdtempSync, writeFileSync, unlinkSync, rmdirSync } = await import(
+        'node:fs'
+      );
+      const { tmpdir } = await import('node:os');
+      const { join } = await import('node:path');
+      const tmpDir = mkdtempSync(join(tmpdir(), 'friend-stt-'));
+      const wavPath = join(tmpDir, 'input.wav');
+      writeFileSync(wavPath, wavBuffer);
+
+      try {
+        await preloadWhisperModel({ language: language || 'en' });
+        const { connectLocalWhisperStream } = await import(
+          '../services/voice/whisperSTT.js'
+        );
+        const result = await new Promise<string>((resolve, reject) => {
+          const chunks: Buffer[] = [];
+          connectLocalWhisperStream(
+            {
+              onTranscript(text, _isFinal) {
+                chunks.push(Buffer.from(text, 'utf8'));
+              },
+              onError(error) {
+                reject(new Error(error));
+              },
+              onClose() {
+                resolve(Buffer.concat(chunks).toString('utf8'));
+              },
+              onReady(conn) {
+                conn.send(wavBuffer);
+                conn.finalize();
+              },
+            },
+            { language: language || 'en' },
+          );
+        });
+        return { text: result };
+      } finally {
+        try { unlinkSync(wavPath) } catch {}
+        try { rmdirSync(tmpDir) } catch {}
+      }
+    }
+
+    case 'doubao': {
+      const { connectDoubaoStream } = await import(
+        '../services/doubaoSTT.js'
+      );
+      const chunks: string[] = [];
+      const conn = await connectDoubaoStream(
+        {
+          onTranscript(text: string, _isFinal: boolean) {
+            chunks.push(text);
+          },
+          onError(_error: string) {},
+          onClose() {},
+          onReady(c: any) {
+            c.send(wavBuffer);
+            c.finalize();
+          },
+        },
+        { language: language || 'zh' },
+      );
+      if (!conn) throw new Error('Doubao STT unavailable');
+      await new Promise((r) => setTimeout(r, 1000));
+      return { text: chunks.join('') };
+    }
+
+    case 'anthropic': {
+      // Fall back to local Whisper for file transcription
+      return transcribeAudioFile(wavBuffer, { ...prefs, sttProvider: 'local' });
+    }
+
+    default:
+      throw new Error(`Unsupported STT provider for file transcription: ${provider}`);
+  }
+}

src/friend/tauri-launcher.ts

@@ -2,85 +2,17 @@
  * Tauri desktop app process management for Friend (VersperClaw native).
  *
  * Launches the VRM desktop pet as a native Tauri window.
- * Also manages a background server on port 3456 that serves the frontend.
+ * The HTTP server runs in-process via friend/server.ts —
+ * no separate server subprocess needed.
  */
-import { spawn, execSync } from 'node:child_process';
+import { spawn } from 'node:child_process';
 import path from 'node:path';
 import { existsSync } from 'node:fs';
 
 let tauriProcess: ReturnType<typeof spawn> | null = null;
-let serverProcess: ReturnType<typeof spawn> | null = null;
-
-const SERVER_PORT = 3456
-const FRIEND_URL = `http://127.0.0.1:${SERVER_PORT}/friend/`
-
-/** Check if the friend server is already listening. */
-function isServerRunning(): boolean {
-  try {
-    const result = execSync(
-      `curl -s -o /dev/null -w "%{http_code}" http://127.0.0.1:${SERVER_PORT}/friend/ 2>/dev/null || true`,
-      { timeout: 3000, encoding: 'utf-8' },
-    )
-    return result.trim() === '200'
-  } catch {
-    return false
-  }
-}
-
-/** Wait until the server responds, up to `timeoutMs`. */
-function waitForServer(timeoutMs = 10_000): Promise<boolean> {
-  const start = Date.now()
-  return new Promise((resolve) => {
-    const check = () => {
-      if (isServerRunning()) return resolve(true)
-      if (Date.now() - start > timeoutMs) return resolve(false)
-      setTimeout(check, 500)
-    }
-    check()
-  })
-}
-
-/** Start the backend server if not already running. */
-async function ensureServer(log: { info: (msg: string) => void; warn: (msg: string) => void }) {
-  if (isServerRunning()) {
-    log.info('[Friend] Server already running')
-    return true
-  }
-
-  const cwd = process.cwd()
-  const serverEntry = path.join(cwd, 'src', 'server', 'index.ts')
-  if (!existsSync(serverEntry)) {
-    log.warn(`[Friend] Server entry not found: ${serverEntry}`)
-    return false
-  }
-
-  log.info('[Friend] Starting background server...')
-  serverProcess = spawn('bun', ['run', serverEntry, `--port=${SERVER_PORT}`], {
-    cwd,
-    stdio: 'pipe',
-    detached: true,
-  })
-
-  serverProcess.stderr?.on('data', (data: Buffer) => {
-    for (const line of data.toString().split('\n').filter(Boolean)) {
-      log.info(`[Friend:server] ${line}`)
-    }
-  })
-
-  const ok = await waitForServer()
-  if (!ok) log.warn('[Friend] Server did not become ready in time')
-  return ok
-}
 
 export async function launchTauri(log: { info: (msg: string) => void; warn: (msg: string) => void }) {
-  // 1. Ensure the server is running (Tauri loads from HTTP)
-  const serverOk = await ensureServer(log)
-  if (!serverOk) {
-    log.warn('[Friend] Cannot start — server failed to start')
-    return
-  }
-
-  // 2. Find the Tauri binary
+  // Find the Tauri binary
   const cwd = process.cwd()
   const releaseBinary = path.join(cwd, 'src', 'components', 'friend', 'frontend', 'src-tauri', 'target', 'release', 'versperclaw-friend')
   const debugBinary = path.join(cwd, 'src', 'components', 'friend', 'frontend', 'src-tauri', 'target', 'debug', 'versperclaw-friend')
@@ -95,7 +27,6 @@ export async function launchTauri(log: { info: (msg: string) => void; warn: (msg
     return
   }
 
-  // 3. Launch the Tauri desktop window (it connects to FRIEND_URL via lib.rs)
   log.info(`[Friend] Starting desktop window from ${binary}`)
 
   tauriProcess = spawn(binary, [], {
@@ -137,12 +68,6 @@ export function stopTauri(log: { info: (msg: string) => void }) {
       try { if (!proc.killed) proc.kill('SIGKILL') } catch { /* ignore */ }
     }, 3000)
   }
-  if (serverProcess) {
-    log.info('[Friend] Stopping background server...')
-    const proc = serverProcess
-    serverProcess = null
-    proc.kill('SIGTERM')
-  }
 }
 
 export function getTauriProcess(): ReturnType<typeof spawn> | null {

src/hooks/useFriendBridge.ts

@@ -0,0 +1,114 @@
+/**
+ * useFriendBridge — Friend VRM inbound/outbound bridge hook.
+ *
+ * Mirror of useFeishuBridge:
+ *   - Tracks AI response turns for Friend-originated messages
+ *   - Broadcasts generated responses to the VRM display via SSE
+ *
+ * The frontend receives responses as SSE events from broadcastToVrm().
+ * No chatId needed — SSE is a broadcast channel to all connected
+ * Tauri display clients.
+ */
+
+import { useEffect, useRef } from 'react'
+import { friendService } from '../friend/FriendService.js'
+import { getContentText } from '../utils/messages.js'
+import type { Message } from '../types/message.js'
+
+type Props = {
+  messages: Message[]
+  isLoading: boolean
+}
+
+const FRIEND_CHANNEL_SERVER = 'friend'
+
+type ActiveFriendTurn = {
+  responseParts: string[]
+}
+
+export function useFriendBridge({ messages, isLoading }: Props): void {
+  const pendingInboundRef = useRef<number>(0) // counter, no chatId needed
+  const activeTurnRef = useRef<ActiveFriendTurn | null>(null)
+  const lastProcessedMessageCountRef = useRef(messages.length)
+  const previousLoadingRef = useRef(isLoading)
+
+  // Subscribe to inbound events (increments counter for turn tracking)
+  useEffect(() => {
+    return friendService.subscribeToInbound(event => {
+      pendingInboundRef.current++
+    })
+  }, [])
+
+  // Process new messages — detect Friend-originated user messages and collect
+  // assistant responses
+  useEffect(() => {
+    const newMessages = messages.slice(lastProcessedMessageCountRef.current)
+
+    for (const message of newMessages) {
+      if (
+        message.type === 'user' &&
+        typeof message.origin === 'object' &&
+        message.origin !== null &&
+        (message.origin as Record<string, unknown>).kind === 'channel' &&
+        (message.origin as Record<string, unknown>).server === FRIEND_CHANNEL_SERVER
+      ) {
+        // Consume one pending inbound
+        if (pendingInboundRef.current > 0) {
+          pendingInboundRef.current--
+          activeTurnRef.current = {
+            responseParts: [],
+          }
+        }
+        continue
+      }
+
+      if (message.type === 'assistant' && activeTurnRef.current) {
+        const text = getContentText(message.message.content)
+        if (text) {
+          activeTurnRef.current.responseParts.push(text)
+        }
+        continue
+      }
+
+      if (
+        message.type === 'system' &&
+        message.subtype === 'local_command' &&
+        activeTurnRef.current
+      ) {
+        const text = message.content
+        if (text) {
+          activeTurnRef.current.responseParts.push(text)
+        }
+      }
+    }
+
+    lastProcessedMessageCountRef.current = messages.length
+  }, [messages])
+
+  // When loading completes, broadcast accumulated response via SSE
+  useEffect(() => {
+    const wasLoading = previousLoadingRef.current
+    previousLoadingRef.current = isLoading
+
+    if (!wasLoading || isLoading || !activeTurnRef.current) return
+
+    const completedTurn = activeTurnRef.current
+    activeTurnRef.current = null
+
+    void (async () => {
+      try {
+        const reply =
+          completedTurn.responseParts.join('\n\n').trim()
+
+        if (reply) {
+          await friendService.broadcastResponse(reply)
+        }
+      } catch (error) {
+        console.warn(
+          '[friend] failed to broadcast reply:',
+          error instanceof Error ? error.message : String(error),
+        )
+      }
+    })()
+  }, [isLoading])
+}

src/screens/REPL.tsx

@@ -113,6 +113,7 @@ import {
 import { endInteractionSpan } from '../utils/telemetry/sessionTracing.js'
 import { useLogMessages } from '../hooks/useLogMessages.js'
 import { useFeishuBridge } from '../hooks/useFeishuBridge.js'
+import { useFriendBridge } from '../hooks/useFriendBridge.js'
 import { useReplBridge } from '../hooks/useReplBridge.js'
 import {
   type Command,
@@ -5403,6 +5404,7 @@ export function REPL({
   useMailboxBridge({ isLoading, onSubmitMessage: handleIncomingPrompt })
 
   useFeishuBridge({ messages, isLoading })
+  useFriendBridge({ messages, isLoading })
 
   // Scheduled tasks from .claude/scheduled_tasks.json (CronCreate/Delete/List)
   if (feature('AGENT_TRIGGERS')) {

src/server/api/friend.ts

@@ -13,7 +13,8 @@ import {
 import { getPrefs, setPrefs, updatePrefs, type FriendPrefs } from '../../friend/prefs.js';
 import { edgeTts, qwenTts, registerAudioFile, getAudioFile } from '../../friend/tts.js';
 import { stripForTts } from '../../friend/text-utils.js';
-import { friendChatService } from '../../friend/chat-service.js';
+import { friendService } from '../../friend/FriendService.js';
+import { transcribeAudioFile } from '../../friend/stt-service.js';
 
 const GATEWAY_URL = `http://127.0.0.1:3456`;
 
@@ -132,24 +133,46 @@ export async function handleFriendApi(req: Request, url: URL): Promise<Response>
     const message = body?.message;
     if (!message) return jsonResponse({ error: 'message required' }, 400);
 
-    // Ensure the Friend CLI session is running (lazy start on first chat).
-    // The response comes back asynchronously via SSE.
-    (async () => {
-      try {
-        await friendChatService.ensureSession(serverHost, serverPort);
-        friendChatService.sendMessage(message);
-      } catch (err) {
-        console.error('[Friend] chat dispatch error:', err);
-        broadcastToVrm({
-          text: `Connection error: ${err instanceof Error ? err.message : String(err)}`,
-        });
-        broadcastToVrm({ replyDone: true });
-      }
-    })();
+    // Enqueue the message into the main CLI conversation via FriendService.
+    // The AI response is tracked by useFriendBridge in the REPL and
+    // broadcast back to the VRM display via SSE automatically.
+    try {
+      await friendService.start();
+      friendService.sendText(message);
+    } catch (err) {
+      console.error('[Friend] chat dispatch error:', err);
+      broadcastToVrm({
+        text: `Connection error: ${err instanceof Error ? err.message : String(err)}`,
+      });
+      broadcastToVrm({ replyDone: true });
+    }
 
     return jsonResponse({ ok: true });
   }
 
+  // ── Voice capture (POST /plugins/friend/voice/start, /stop, /status) ──
+  if (pathname === '/plugins/friend/voice/start' && method === 'POST') {
+    try {
+      await friendService.startVoiceCapture();
+      return jsonResponse({ ok: true });
+    } catch (err) {
+      return jsonResponse({ error: String(err) }, 500);
+    }
+  }
+
+  if (pathname === '/plugins/friend/voice/stop' && method === 'POST') {
+    try {
+      const text = await friendService.stopVoiceCapture();
+      return jsonResponse({ ok: true, text });
+    } catch (err) {
+      return jsonResponse({ error: String(err) }, 500);
+    }
+  }
+
+  if (pathname === '/plugins/friend/voice/status' && method === 'POST') {
+    return jsonResponse(friendService.getCaptureStatus());
+  }
+
   // ── Touch endpoint (POST /plugins/friend/touch) ──
   if (pathname === '/plugins/friend/touch' && method === 'POST') {
     const body = await readJsonBody(req) as any;
@@ -190,6 +213,31 @@ export async function handleFriendApi(req: Request, url: URL): Promise<Response>
     return new Response(null, { status: 405 });
   }
 
+  // ── STT config (GET /plugins/friend/stt/config) ──
+  if (pathname === '/plugins/friend/stt/config' && method === 'GET') {
+    const prefs = getPrefs();
+    return jsonResponse({
+      sttProvider: prefs.sttProvider || 'browser',
+      sttLanguage: prefs.sttLanguage || 'zh',
+    });
+  }
+
+  // ── STT file transcription (POST /plugins/friend/stt/file) ──
+  if (pathname === '/plugins/friend/stt/file' && method === 'POST') {
+    try {
+      const formData = await req.formData();
+      const audioFile = formData.get('audio') as File | null;
+      if (!audioFile) return jsonResponse({ error: 'audio file required' }, 400);
+
+      const buffer = Buffer.from(await audioFile.arrayBuffer());
+      const prefs = getPrefs();
+      const result = await transcribeAudioFile(buffer, prefs);
+      return jsonResponse(result);
+    } catch (err) {
+      return jsonResponse({ error: String(err) }, 500);
+    }
+  }
+
   // ── TTS Preview (POST /plugins/friend/preview) ──
   if (pathname === '/plugins/friend/preview' && method === 'POST') {
     const body = await readJsonBody(req) as any;
@@ -239,6 +287,8 @@ export async function handleFriendApi(req: Request, url: URL): Promise<Response>
         currentDance: prefs.currentDance,
         language: prefs.language,
         hideMood: prefs.hideMood,
+        sttProvider: prefs.sttProvider || 'browser',
+        sttLanguage: prefs.sttLanguage || 'zh',
       });
     }
 
@@ -257,6 +307,8 @@ export async function handleFriendApi(req: Request, url: URL): Promise<Response>
       if (body.currentDance !== undefined) patch.currentDance = body.currentDance;
       if (body.language !== undefined) patch.language = body.language;
       if (body.hideMood !== undefined) patch.hideMood = body.hideMood;
+      if (body.sttProvider !== undefined) patch.sttProvider = body.sttProvider;
+      if (body.sttLanguage !== undefined) patch.sttLanguage = body.sttLanguage;
       setPrefs(updatePrefs(patch));
       return jsonResponse({ ok: true });
     }
@@ -380,7 +432,7 @@ export async function handleFriendApi(req: Request, url: URL): Promise<Response>
   // ── Clear context (POST /plugins/friend/context/clear) ──
   if (pathname === '/plugins/friend/context/clear' && method === 'POST') {
     broadcastToVrm({ clearText: true });
-    friendChatService.clearContext();
+    friendService.sendText('/new');
     return jsonResponse({ ok: true });
   }
 

src/server/index.ts

@@ -18,7 +18,6 @@ import { handleHahaOpenAIOAuthCallback } from './api/haha-openai-oauth.js'
 import { handleFriendApi, setFriendServerInfo } from './api/friend.js'
 import { handleFriendStaticRequest } from './staticFriend.js'
 import { getPrefs } from '../friend/prefs.js'
-import { launchTauri, stopTauri } from '../friend/tauri-launcher.js'
 import { fileURLToPath } from 'node:url'
 import path from 'node:path'
 import { OPENAI_CODEX_REDIRECT_PATH } from '../services/openaiAuth/client.js'
@@ -428,19 +427,12 @@ export function startServer(port = PORT, host = HOST) {
 
   console.log(`[Server] Claude Code API server running at http://${host}:${port}`)
 
-  // Register Friend server info so the chat service can construct SDK URLs
+  // Register Friend server info so API routes can construct URLs
   setFriendServerInfo(host, port)
 
-  // ── Friend: launch Tauri desktop window when enabled ──
-  if (getPrefs().enabled) {
-    const friendUrl = `http://${localConnectHost}:${port}/friend/`
-    console.log(`[Friend] VRM frontend available at ${friendUrl}`)
-
-    launchTauri({
-      info: (msg: string) => console.log(`[Friend] ${msg}`),
-      warn: (msg: string) => console.warn(`[Friend] ${msg}`),
-    })
-  }
+  // Note: Friend Tauri window lifecycle is managed by the friend module
+  // (FriendService + friend/server.ts), not by the desktop server.
+  // Use `/friend start` in the CLI to launch the window.
 
   return server
 }
@@ -458,29 +450,20 @@ function cleanupAllSessions() {
   }
 }
 
-function cleanupFriend() {
-  stopTauri({
-    info: (msg: string) => console.log(`[Friend] ${msg}`),
-  })
-}
-
 process.on('SIGTERM', () => {
   console.log('[Server] Received SIGTERM')
   cleanupAllSessions()
-  cleanupFriend()
   process.exit(0)
 })
 
 process.on('SIGINT', () => {
   console.log('[Server] Received SIGINT')
   cleanupAllSessions()
-  cleanupFriend()
   process.exit(0)
 })
 
 process.on('exit', () => {
   cleanupAllSessions()
-  cleanupFriend()
 })
 
 // Direct execution

src/server/staticFriend.ts

@@ -69,17 +69,25 @@ export async function handleFriendStaticRequest(req: Request, url: URL): Promise
 }
 
 async function resolveFriendDistDir(): Promise<string | null> {
+  // Method 1: relative to source file (works in dev mode / server subprocess)
   const _srcDir = path.dirname(fileURLToPath(import.meta.url))
-  // src/server/ -> ../../src/components/friend/frontend/dist
-  const candidate = path.resolve(_srcDir, '..', '..', 'src', 'components', 'friend', 'frontend', 'dist')
+  const candidate1 = path.resolve(_srcDir, '..', '..', 'src', 'components', 'friend', 'frontend', 'dist')
   try {
-    const stat = await fs.stat(path.join(candidate, 'index.html'))
-    if (stat.isFile()) {
-      return candidate
-    }
+    const stat = await fs.stat(path.join(candidate1, 'index.html'))
+    if (stat.isFile()) return candidate1
   } catch {
     // Not found
   }
+
+  // Method 2: relative to cwd (works in compiled binary where import.meta.url is virtual)
+  const candidate2 = path.resolve(process.cwd(), 'src', 'components', 'friend', 'frontend', 'dist')
+  try {
+    const stat = await fs.stat(path.join(candidate2, 'index.html'))
+    if (stat.isFile()) return candidate2
+  } catch {
+    // Not found
+  }
+
   return null
 }
 

src/server/ws/handler.ts

@@ -29,7 +29,6 @@ import {
   LOCAL_COMMAND_STDOUT_TAG,
 } from '../../constants/xml.js'
 import { shouldCreateWorktreeForSessionLaunch } from '../services/repositoryLaunchService.js'
-
 const settingsService = new SettingsService()
 const providerService = new ProviderService()
 

src/utils/desktopBundledCli.ts

@@ -24,9 +24,23 @@ export function resolveBundledCliPathFromExecPath(
     return fs.existsSync(bundledCliPath) ? bundledCliPath : null
   }
 
+  // If execPath points to an existing regular file, it IS the CLI binary
+  // (handles standalone compiled binaries like VersperClaw, cli, etc.)
+  if (existsAndIsFile(execPath)) {
+    return execPath
+  }
+
   return null
 }
 
+function existsAndIsFile(p: string): boolean {
+  try {
+    return fs.statSync(p).isFile()
+  } catch {
+    return false
+  }
+}
+
 export function resolveClaudeCliLauncher(options?: {
   cliPath?: string | null
   execPath?: string