voicesmith-mcp 1.0.18 → 1.0.19

package/README.md

@@ -77,6 +77,43 @@ In a meeting or shared space? Just ask:
 
 The AI continues working normally — it just won't play audio. Say *"unmute"* when you're ready.
 
+---
+
+### Menu Bar App (macOS)
+
+On macOS, VoiceSmith includes a native menu bar app for hands-free control:
+
+- **Session Activity** — see all active sessions with real-time sparkline graphs
+- **Quick toggles** — Media Ducking, Nudge on Timeout
+- **Voice switcher** — browse and change from 54 voices, nested by language
+- **Whisper model** — switch between base/small/medium/large-v3 with inline download progress
+- **Audio devices** — choose audio output and input devices
+- **Voice rules** — edit or reset to default
+- **Updates** — check and install new versions
+
+The menu bar app starts automatically at login and runs independently from IDE sessions.
+
+---
+
+### Audio Device Selection
+
+Choose specific audio output (speakers/headphones) and input (microphone) devices from the menu bar app, or in config:
+
+```json
+{
+  "tts": { "audio_output_device": "coreaudio/BuiltInSpeakerDevice" },
+  "stt": { "audio_input_device": 1 }
+}
+```
+
+Changes take effect immediately — no restart needed. If a configured device is unavailable, falls back to system default.
+
+---
+
+### Interrupting Speech
+
+Press **Escape** while the AI is speaking to stop audio immediately. The AI stops mid-sentence and waits for your next input.
+
 ## Alternative Install
 
 If you don't have Node.js or prefer a shell script:
@@ -87,7 +124,7 @@ cd voicesmith-mcp
 ./install.sh
 ```
 
-Supports the same flags: `--claude`, `--cursor`, `--codex`, `--all`.
+Supports the same flags: `--claude`, `--cursor`, `--codex`, `--all`, `--uninstall`.
 
 ## MCP Tools
 
@@ -104,6 +141,7 @@ Once installed, your AI assistant has access to these tools:
 | `mute` / `unmute` | Silence or resume voice output |
 | `stop` | Stop playback or cancel an active recording |
 | `status` | Server health and session info |
+| `list_audio_devices` | List available audio input and output devices |
 
 ## How It Works
 
@@ -216,9 +254,11 @@ This can happen when another session is holding your preferred voice name. Ask t
 
 ```bash
 npx voicesmith-mcp uninstall
+# or if installed via git clone:
+./install.sh --uninstall
 ```
 
-Removes all files, models, MCP config entries, and voice rules cleanly.
+Removes all files, models, MCP config entries, voice rules, LaunchAgents, and hooks cleanly.
 
 ## License
 

package/bin/install.js

@@ -462,6 +462,122 @@ except Exception as e:
   }
 }
 
+// ─── Step 5b: Menu Bar App (macOS only) ──────────────────────────────────────
+
+async function step5b_menuBar() {
+  if (process.platform !== "darwin") return;
+
+  const menubarSrc = path.join(__dirname, "..", "menubar", "VoiceSmithMenu.swift");
+  const menubarIconSrc = path.join(__dirname, "..", "menubar", "app-icon.png");
+  const menubarPlistTemplate = path.join(__dirname, "..", "menubar", "com.voicesmith-mcp.menubar.plist");
+
+  if (!fs.existsSync(menubarSrc)) {
+    logWarn("Menu bar source not found — skipping");
+    return;
+  }
+
+  // Check for swiftc
+  if (!(await commandExists("swiftc"))) {
+    logWarn("swiftc not found — menu bar app requires Xcode Command Line Tools");
+    logInfo("Install with: xcode-select --install");
+    return;
+  }
+
+  const menubarApp = path.join(INSTALL_DIR, "VoiceSmith.app");
+  const menubarBinDir = path.join(menubarApp, "Contents", "MacOS");
+  const menubarResDir = path.join(menubarApp, "Contents", "Resources");
+  const menubarBinary = path.join(menubarBinDir, "VoiceSmith");
+  const menubarPlist = path.join(os.homedir(), "Library", "LaunchAgents", "com.voicesmith-mcp.menubar.plist");
+
+  // Create app bundle structure
+  fs.mkdirSync(menubarBinDir, { recursive: true });
+  fs.mkdirSync(menubarResDir, { recursive: true });
+
+  // Create Info.plist
+  const infoPlist = `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+    <key>CFBundleExecutable</key>
+    <string>VoiceSmith</string>
+    <key>CFBundleIdentifier</key>
+    <string>com.voicesmith-mcp.menubar</string>
+    <key>CFBundleName</key>
+    <string>VoiceSmith</string>
+    <key>CFBundleDisplayName</key>
+    <string>VoiceSmith</string>
+    <key>CFBundlePackageType</key>
+    <string>APPL</string>
+    <key>CFBundleShortVersionString</key>
+    <string>1.0</string>
+    <key>CFBundleVersion</key>
+    <string>1</string>
+    <key>CFBundleIconFile</key>
+    <string>AppIcon</string>
+    <key>LSBackgroundOnly</key>
+    <true/>
+    <key>LSUIElement</key>
+    <true/>
+</dict>
+</plist>`;
+  fs.writeFileSync(path.join(menubarApp, "Contents", "Info.plist"), infoPlist);
+
+  // Compile Swift
+  logAction("Building VoiceSmith menu bar app...");
+  const buildResult = await runCommand("swiftc", [
+    "-parse-as-library",
+    "-framework", "SwiftUI",
+    "-framework", "AppKit",
+    menubarSrc,
+    "-o", menubarBinary,
+  ]);
+
+  if (!buildResult.success) {
+    logWarn("Menu bar build failed — menu bar will not be available");
+    return;
+  }
+
+  // Generate icon
+  if (fs.existsSync(menubarIconSrc)) {
+    const { execSync } = require("child_process");
+    const iconsetDir = path.join(os.tmpdir(), "VoiceSmithIcon.iconset");
+    fs.mkdirSync(iconsetDir, { recursive: true });
+    const sizes = [16, 32, 64, 128, 256, 512];
+    try {
+      for (const s of sizes) {
+        execSync(`sips -z ${s} ${s} "${menubarIconSrc}" --out "${path.join(iconsetDir, `icon_${s}x${s}.png`)}"`, { stdio: "ignore" });
+      }
+      execSync(`sips -z 32 32 "${menubarIconSrc}" --out "${path.join(iconsetDir, "icon_16x16@2x.png")}"`, { stdio: "ignore" });
+      execSync(`sips -z 64 64 "${menubarIconSrc}" --out "${path.join(iconsetDir, "icon_32x32@2x.png")}"`, { stdio: "ignore" });
+      execSync(`sips -z 256 256 "${menubarIconSrc}" --out "${path.join(iconsetDir, "icon_128x128@2x.png")}"`, { stdio: "ignore" });
+      execSync(`sips -z 512 512 "${menubarIconSrc}" --out "${path.join(iconsetDir, "icon_256x256@2x.png")}"`, { stdio: "ignore" });
+      execSync(`sips -z 1024 1024 "${menubarIconSrc}" --out "${path.join(iconsetDir, "icon_512x512@2x.png")}"`, { stdio: "ignore" });
+      execSync(`iconutil -c icns "${iconsetDir}" -o "${path.join(menubarResDir, "AppIcon.icns")}"`, { stdio: "ignore" });
+    } catch (e) { /* icon generation is optional */ }
+    fs.rmSync(iconsetDir, { recursive: true, force: true });
+  }
+
+  // Codesign
+  await runCommand("codesign", ["-s", "-", "--force", menubarApp]);
+  logActionDone("VoiceSmith menu bar app built");
+
+  // Install LaunchAgent
+  if (fs.existsSync(menubarPlistTemplate)) {
+    fs.mkdirSync(path.dirname(menubarPlist), { recursive: true });
+    let plistContent = fs.readFileSync(menubarPlistTemplate, "utf8");
+    plistContent = plistContent.replace(/MENUBAR_BINARY/g, menubarBinary);
+    fs.writeFileSync(menubarPlist, plistContent);
+
+    await runCommand("launchctl", ["unload", menubarPlist]);
+    const loadResult = await runCommand("launchctl", ["load", "-w", menubarPlist]);
+    if (loadResult.success) {
+      logOk("VoiceSmith menu bar started (runs at login)");
+    } else {
+      logWarn("Menu bar LaunchAgent install failed");
+    }
+  }
+}
+
 // ─── Voice Picker ────────────────────────────────────────────────────────────
 
 const DEFAULT_VOICES = [
@@ -726,6 +842,7 @@ async function run() {
   await step3_models();
   const configuredIdes = await step4_mcpConfig(targetIdes);
   await step5_microphone();
+  await step5b_menuBar();
   await step6_voiceRules(configuredIdes);
 
   const ideNames = (configuredIdes || [])

package/bin/uninstall.js

@@ -6,6 +6,7 @@
 
 const fs = require("fs");
 const path = require("path");
+const os = require("os");
 
 const {
   INSTALL_DIR,
@@ -60,6 +61,22 @@ async function run() {
 
   console.log("");
 
+  // Unload and remove LaunchAgents before deleting the install directory
+  const { execSync } = require("child_process");
+  const launchAgents = [
+    path.join(os.homedir(), "Library", "LaunchAgents", "com.voicesmith-mcp.audio.plist"),
+    path.join(os.homedir(), "Library", "LaunchAgents", "com.voicesmith-mcp.menubar.plist"),
+  ];
+  for (const plist of launchAgents) {
+    if (fileExists(plist)) {
+      try {
+        execSync(`launchctl unload "${plist}" 2>/dev/null`, { stdio: "ignore" });
+        fs.unlinkSync(plist);
+        logOk(`Removed LaunchAgent: ${path.basename(plist)}`);
+      } catch (e) { /* ignore */ }
+    }
+  }
+
   // Remove install directory (venv, models, server files, config)
   if (dirExists(INSTALL_DIR)) {
     fs.rmSync(INSTALL_DIR, { recursive: true, force: true });

package/config.json

@@ -20,6 +20,7 @@
   "log_level": "info",
   "log_file": false,
   "http_port": 7865,
+  "check_updates": true,
   "wake_word": {
     "enabled": false,
     "model": "hey_listen",

package/config.py

@@ -28,6 +28,7 @@ class TTSConfig:
     default_speed: float = 1.0
     audio_player: str = "mpv"
     duck_media: bool = False
+    audio_output_device: Optional[str] = None  # mpv device name, None = system default
 
 
 @dataclass
@@ -38,6 +39,7 @@ class STTConfig:
     max_listen_timeout: float = 15
     vad_threshold: float = 0.3
     nudge_on_timeout: bool = False
+    audio_input_device: Optional[int] = None  # sounddevice device index, None = system default
 
 
 @dataclass
@@ -61,6 +63,7 @@ class AppConfig:
     log_level: str = "info"
     log_file: bool = False
     http_port: int = 7865
+    check_updates: bool = True
 
 
 def get_config_path() -> Path:
@@ -104,6 +107,8 @@ def load_config(config_path: Optional[Path] = None) -> AppConfig:
                     config.tts.audio_player = tts["audio_player"]
                 if "duck_media" in tts:
                     config.tts.duck_media = bool(tts["duck_media"])
+                if "audio_output_device" in tts:
+                    config.tts.audio_output_device = tts["audio_output_device"]
 
             # STT config
             if "stt" in data:
@@ -120,6 +125,9 @@ def load_config(config_path: Optional[Path] = None) -> AppConfig:
                     config.stt.vad_threshold = float(stt["vad_threshold"])
                 if "nudge_on_timeout" in stt:
                     config.stt.nudge_on_timeout = bool(stt["nudge_on_timeout"])
+                if "audio_input_device" in stt:
+                    val = stt["audio_input_device"]
+                    config.stt.audio_input_device = int(val) if val is not None else None
 
             # Top-level config
             if "main_agent" in data:
@@ -134,6 +142,8 @@ def load_config(config_path: Optional[Path] = None) -> AppConfig:
                 config.log_file = bool(data["log_file"])
             if "http_port" in data:
                 config.http_port = int(data["http_port"])
+            if "check_updates" in data:
+                config.check_updates = bool(data["check_updates"])
 
             # Wake word config
             if "wake_word" in data:
@@ -187,6 +197,7 @@ def save_config(config: AppConfig, config_path: Optional[Path] = None) -> None:
             "default_speed": config.tts.default_speed,
             "audio_player": config.tts.audio_player,
             "duck_media": config.tts.duck_media,
+            "audio_output_device": config.tts.audio_output_device,
         },
         "stt": {
             "model_size": config.stt.model_size,
@@ -195,6 +206,7 @@ def save_config(config: AppConfig, config_path: Optional[Path] = None) -> None:
             "max_listen_timeout": config.stt.max_listen_timeout,
             "vad_threshold": config.stt.vad_threshold,
             "nudge_on_timeout": config.stt.nudge_on_timeout,
+            "audio_input_device": config.stt.audio_input_device,
         },
         "main_agent": config.main_agent,
         "last_voice_name": config.last_voice_name,
@@ -202,6 +214,7 @@ def save_config(config: AppConfig, config_path: Optional[Path] = None) -> None:
         "log_level": config.log_level,
         "log_file": config.log_file,
         "http_port": config.http_port,
+        "check_updates": config.check_updates,
         "wake_word": {
             "enabled": config.wake_word.enabled,
             "model": config.wake_word.model,

package/hooks/session-start.sh

@@ -94,36 +94,29 @@ except:
         fi
     fi
 
-    # Fallback: read sessions.json directly if HTTP call didn't work
-    if [ -z "$SESSION_NAME" ]; then
-        SESSION_INFO=$(python3 -c "
-import json, os
+    # Fallback: query the server's /status endpoint for the actual name
+    if [ -z "$SESSION_NAME" ] && [ -n "$PORT" ]; then
+        STATUS=$(curl -s --max-time 2 "http://127.0.0.1:$PORT/status" 2>/dev/null)
+        if [ -n "$STATUS" ]; then
+            SESSION_NAME=$(echo "$STATUS" | python3 -c "
+import sys, json
 try:
-    with open('$SESSIONS_FILE') as f:
-        data = json.load(f)
-    tmux = os.environ.get('VOICESMITH_TMUX', '')
-    for s in data.get('sessions', []):
-        try:
-            os.kill(s['pid'], 0)
-            if tmux and s.get('tmux_session') == tmux:
-                print(f\"{s['name']}|{s['voice']}\")
-                raise SystemExit
-        except (OSError, ProcessLookupError):
-            pass
-    for s in reversed(data.get('sessions', [])):
-        try:
-            os.kill(s['pid'], 0)
-            print(f\"{s['name']}|{s['voice']}\")
-            break
-        except (OSError, ProcessLookupError):
-            pass
+    d = json.load(sys.stdin)
+    # Check session object first (new servers), fall back to top-level name
+    s = d.get('session') or d
+    print(s.get('name', ''))
+except:
+    pass
+" 2>/dev/null)
+            SESSION_VOICE=$(echo "$STATUS" | python3 -c "
+import sys, json
+try:
+    d = json.load(sys.stdin)
+    s = d.get('session') or d
+    print(s.get('voice', ''))
 except:
     pass
 " 2>/dev/null)
-
-        if [ -n "$SESSION_INFO" ]; then
-            SESSION_NAME=$(echo "$SESSION_INFO" | cut -d'|' -f1)
-            SESSION_VOICE=$(echo "$SESSION_INFO" | cut -d'|' -f2)
         fi
     fi
 fi

package/launcher/Info.plist

@@ -0,0 +1,25 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN"
+    "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+    <key>CFBundleExecutable</key>
+    <string>VoiceSmithMCP</string>
+    <key>CFBundleIdentifier</key>
+    <string>com.voicesmith-mcp.launcher</string>
+    <key>CFBundleName</key>
+    <string>VoiceSmithMCP</string>
+    <key>CFBundlePackageType</key>
+    <string>APPL</string>
+    <key>CFBundleShortVersionString</key>
+    <string>1.0</string>
+    <key>CFBundleVersion</key>
+    <string>1</string>
+    <!-- Background-only: no Dock icon or app switcher entry -->
+    <key>LSBackgroundOnly</key>
+    <true/>
+    <!-- Required for macOS TCC to show a mic permission dialog for this bundle -->
+    <key>NSMicrophoneUsageDescription</key>
+    <string>VoiceSmith MCP uses the microphone to transcribe voice input for Claude.</string>
+</dict>
+</plist>

package/launcher/audio_service.c

@@ -0,0 +1,267 @@
+/*
+ * audio_service.c — Unix-socket mic streaming daemon for VoiceSmithMCP
+ *
+ * Runs as a LaunchAgent (launchd spawns it, ppid=1).  Because it is spawned
+ * by launchd — not by a terminal app — macOS TCC attributes microphone
+ * access to VoiceSmithMCP.app (com.voicesmith-mcp.launcher) rather than to
+ * the user's terminal, which typically lacks NSMicrophoneUsageDescription.
+ *
+ * Protocol (Unix domain socket at SOCKET_PATH):
+ *   - Service creates the socket file, then loops accepting connections.
+ *   - Supports MULTIPLE concurrent clients — audio is broadcast to all.
+ *   - On connection: add client to the list, start recording if not already.
+ *   - On client disconnect: remove from list, stop recording if no clients.
+ *   - On SIGTERM/SIGINT: stop cleanly and exit 0.
+ *   - On CoreAudio error: write message to stderr and exit 1.
+ *
+ * Build (handled by install.sh):
+ *   clang -framework AudioToolbox -framework CoreFoundation \
+ *         audio_service.c -o audio-service
+ */
+
+#include <AudioToolbox/AudioToolbox.h>
+#include <CoreFoundation/CoreFoundation.h>
+#include <errno.h>
+#include <fcntl.h>
+#include <pthread.h>
+#include <signal.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/socket.h>
+#include <sys/un.h>
+#include <unistd.h>
+
+#define SAMPLE_RATE      16000
+#define CHANNELS         1
+#define BYTES_PER_SAMPLE 4          /* float32 */
+#define CHUNK_SAMPLES    512        /* Silero VAD requires 512-sample chunks */
+#define CHUNK_BYTES      (CHUNK_SAMPLES * BYTES_PER_SAMPLE)  /* 2048 */
+#define NUM_BUFFERS      3
+#define BUFFER_FRAMES    (CHUNK_SAMPLES * 4)
+#define BUFFER_BYTES     (BUFFER_FRAMES * BYTES_PER_SAMPLE)
+
+#define SOCKET_PATH      "/tmp/voicesmith-audio.sock"
+#define MAX_CLIENTS      8
+
+/* ── Global state ────────────────────────────────────────────────────────── */
+
+static volatile sig_atomic_t g_running = 1;
+static AudioQueueRef         g_queue   = NULL;
+
+/* Client tracking */
+static int             g_clients[MAX_CLIENTS];
+static int             g_num_clients = 0;
+static pthread_mutex_t g_lock = PTHREAD_MUTEX_INITIALIZER;
+
+static void handle_signal(int sig)
+{
+    (void)sig;
+    g_running = 0;
+    if (g_queue)
+        AudioQueueStop(g_queue, /*inImmediate=*/true);
+}
+
+/* ── Client management ───────────────────────────────────────────────────── */
+
+static void add_client(int fd)
+{
+    pthread_mutex_lock(&g_lock);
+    if (g_num_clients < MAX_CLIENTS) {
+        g_clients[g_num_clients++] = fd;
+        fprintf(stderr, "audio-service: client added (fd=%d, total=%d)\n", fd, g_num_clients);
+    } else {
+        fprintf(stderr, "audio-service: max clients reached, rejecting fd=%d\n", fd);
+        close(fd);
+    }
+    pthread_mutex_unlock(&g_lock);
+}
+
+static void remove_client(int fd)
+{
+    pthread_mutex_lock(&g_lock);
+    for (int i = 0; i < g_num_clients; i++) {
+        if (g_clients[i] == fd) {
+            g_clients[i] = g_clients[--g_num_clients];
+            fprintf(stderr, "audio-service: client removed (fd=%d, total=%d)\n", fd, g_num_clients);
+            break;
+        }
+    }
+    pthread_mutex_unlock(&g_lock);
+    close(fd);
+}
+
+/* ── Per-callback accumulation state ─────────────────────────────────────── */
+
+typedef struct {
+    float staging[CHUNK_SAMPLES];
+    int   pos;
+} State;
+
+/* ── AudioQueue input callback ───────────────────────────────────────────── */
+
+static void audio_callback(
+    void                               *user_data,
+    AudioQueueRef                       queue,
+    AudioQueueBufferRef                 buffer,
+    const AudioTimeStamp               *start_time,
+    UInt32                              num_packets,
+    const AudioStreamPacketDescription *packet_desc)
+{
+    (void)start_time; (void)num_packets; (void)packet_desc;
+
+    State       *state   = (State *)user_data;
+    const float *samples = (const float *)buffer->mAudioData;
+    UInt32       n       = buffer->mAudioDataByteSize / BYTES_PER_SAMPLE;
+
+    for (UInt32 i = 0; i < n && g_running; i++) {
+        state->staging[state->pos++] = samples[i];
+        if (state->pos == CHUNK_SAMPLES) {
+            /* Broadcast chunk to all connected clients */
+            pthread_mutex_lock(&g_lock);
+            for (int c = 0; c < g_num_clients; /* no increment */) {
+                const char *p   = (const char *)state->staging;
+                ssize_t     rem = (ssize_t)CHUNK_BYTES;
+                int         ok  = 1;
+                while (rem > 0) {
+                    ssize_t r = write(g_clients[c], p, (size_t)rem);
+                    if (r < 0) {
+                        if (errno == EINTR) continue;
+                        /* Client disconnected — remove it */
+                        int dead_fd = g_clients[c];
+                        g_clients[c] = g_clients[--g_num_clients];
+                        close(dead_fd);
+                        fprintf(stderr, "audio-service: client dropped (fd=%d, total=%d)\n",
+                                dead_fd, g_num_clients);
+                        ok = 0;
+                        break;
+                    }
+                    p   += r;
+                    rem -= r;
+                }
+                if (ok) c++;  /* only advance if we didn't remove */
+            }
+            pthread_mutex_unlock(&g_lock);
+            state->pos = 0;
+        }
+    }
+
+    if (g_running)
+        AudioQueueEnqueueBuffer(queue, buffer, 0, NULL);
+}
+
+/* ── start_queue: create and start an AudioQueue ─────────────────────────── */
+
+static OSStatus start_queue(AudioQueueRef *out_queue, State *state)
+{
+    AudioStreamBasicDescription fmt;
+    memset(&fmt, 0, sizeof(fmt));
+    fmt.mSampleRate       = SAMPLE_RATE;
+    fmt.mFormatID         = kAudioFormatLinearPCM;
+    fmt.mFormatFlags      = kAudioFormatFlagIsFloat | kAudioFormatFlagIsPacked;
+    fmt.mBitsPerChannel   = 32;
+    fmt.mChannelsPerFrame = CHANNELS;
+    fmt.mBytesPerFrame    = BYTES_PER_SAMPLE * CHANNELS;
+    fmt.mFramesPerPacket  = 1;
+    fmt.mBytesPerPacket   = fmt.mBytesPerFrame;
+
+    memset(state, 0, sizeof(*state));
+
+    AudioQueueRef queue;
+    OSStatus err = AudioQueueNewInput(&fmt, audio_callback, state,
+                                      NULL, NULL, 0, &queue);
+    if (err != noErr) return err;
+
+    for (int i = 0; i < NUM_BUFFERS; i++) {
+        AudioQueueBufferRef buf;
+        err = AudioQueueAllocateBuffer(queue, BUFFER_BYTES, &buf);
+        if (err != noErr) { AudioQueueDispose(queue, true); return err; }
+        AudioQueueEnqueueBuffer(queue, buf, 0, NULL);
+    }
+
+    err = AudioQueueStart(queue, NULL);
+    if (err != noErr) { AudioQueueDispose(queue, true); return err; }
+
+    *out_queue = queue;
+    return noErr;
+}
+
+/* ── Accept thread: accepts new clients in the background ────────────────── */
+
+static int g_server_fd = -1;
+
+static void *accept_thread(void *arg)
+{
+    (void)arg;
+    while (g_running) {
+        int client_fd = accept(g_server_fd, NULL, NULL);
+        if (client_fd < 0) {
+            if (errno == EINTR) continue;
+            break;
+        }
+        add_client(client_fd);
+    }
+    return NULL;
+}
+
+/* ── main ────────────────────────────────────────────────────────────────── */
+
+int main(void)
+{
+    signal(SIGTERM, handle_signal);
+    signal(SIGINT,  handle_signal);
+    signal(SIGPIPE, SIG_IGN);
+
+    /* Create Unix socket */
+    g_server_fd = socket(AF_UNIX, SOCK_STREAM, 0);
+    if (g_server_fd < 0) {
+        fprintf(stderr, "audio-service: socket: %s\n", strerror(errno));
+        return 1;
+    }
+
+    unlink(SOCKET_PATH);
+
+    struct sockaddr_un addr;
+    memset(&addr, 0, sizeof(addr));
+    addr.sun_family = AF_UNIX;
+    strncpy(addr.sun_path, SOCKET_PATH, sizeof(addr.sun_path) - 1);
+
+    if (bind(g_server_fd, (struct sockaddr *)&addr, sizeof(addr)) < 0) {
+        fprintf(stderr, "audio-service: bind: %s\n", strerror(errno));
+        return 1;
+    }
+    if (listen(g_server_fd, MAX_CLIENTS) < 0) {
+        fprintf(stderr, "audio-service: listen: %s\n", strerror(errno));
+        return 1;
+    }
+
+    /* Start AudioQueue — always recording, broadcasting to all clients */
+    State state;
+    OSStatus err = start_queue(&g_queue, &state);
+    if (err != noErr) {
+        fprintf(stderr, "audio-service: AudioQueue error (%d)\n", (int)err);
+        return 1;
+    }
+
+    /* Start accept thread for new connections */
+    pthread_t tid;
+    pthread_create(&tid, NULL, accept_thread, NULL);
+
+    /* Run CoreAudio run loop */
+    while (g_running)
+        CFRunLoopRunInMode(kCFRunLoopDefaultMode, 0.1, false);
+
+    /* Cleanup */
+    AudioQueueStop(g_queue, true);
+    AudioQueueDispose(g_queue, true);
+
+    pthread_mutex_lock(&g_lock);
+    for (int i = 0; i < g_num_clients; i++)
+        close(g_clients[i]);
+    g_num_clients = 0;
+    pthread_mutex_unlock(&g_lock);
+
+    close(g_server_fd);
+    unlink(SOCKET_PATH);
+    return 0;
+}