pi-voice 0.1.0 → 0.2.0

package/out/main/index.js

@@ -1,76 +1,435 @@
-import { app, session as session$1, BrowserWindow, ipcMain } from "electron";
+import { systemPreferences, app, BrowserWindow, ipcMain } from "electron";
 import { fileURLToPath } from "node:url";
-import iohook from "iohook-macos";
-import { GoogleGenAI } from "@google/genai";
-import { createAgentSession, SessionManager } from "@mariozechner/pi-coding-agent";
+import { uIOhook, UiohookKey } from "uiohook-napi";
 import { join } from "node:path";
 import { homedir } from "node:os";
-import { writeFileSync, existsSync, unlinkSync, mkdirSync } from "node:fs";
+import pino from "pino";
+import { readFileSync, existsSync, mkdirSync, createWriteStream, unlinkSync, writeFileSync } from "node:fs";
+import { z } from "zod";
+import { GoogleGenAI } from "@google/genai";
+import OpenAI, { toFile } from "openai";
+import { WhisperFullParams, WhisperSamplingStrategy, Whisper } from "@napi-rs/whisper";
+import { Readable } from "node:stream";
+import { finished } from "node:stream/promises";
+import { spawn } from "node:child_process";
+import { createAgentSession, SessionManager } from "@mariozechner/pi-coding-agent";
 import { createServer } from "node:net";
+function resolveLogPath() {
+  const envPath = process.env["PI_VOICE_LOG_PATH"];
+  if (envPath) return envPath;
+  const configHome = process.env["XDG_CONFIG_HOME"] || join(homedir(), ".config");
+  return join(configHome, "pi-voice", "daemon.log");
+}
+const logPath = resolveLogPath();
+const logger = pino(
+  {
+    level: "debug"
+  },
+  pino.multistream([
+    // Console output (human-readable via stdout)
+    { level: "debug", stream: process.stdout },
+    // File output (JSON, auto-creates parent directories)
+    {
+      level: "debug",
+      stream: pino.destination({ dest: logPath, mkdir: true, sync: false })
+    }
+  ])
+);
+function getReleaseCodes(binding) {
+  const codes = [binding.keycode];
+  if (binding.ctrl) {
+    codes.push(UiohookKey.Ctrl, UiohookKey.CtrlRight);
+  }
+  if (binding.shift) {
+    codes.push(UiohookKey.Shift, UiohookKey.ShiftRight);
+  }
+  if (binding.alt) {
+    codes.push(UiohookKey.Alt, UiohookKey.AltRight);
+  }
+  if (binding.meta) {
+    codes.push(UiohookKey.Meta, UiohookKey.MetaRight);
+  }
+  return codes;
+}
 class FnHook {
-  fnDown = false;
+  active = false;
   callbacks;
   started = false;
-  constructor(callbacks) {
+  binding;
+  releaseCodes;
+  displayName;
+  constructor(callbacks, binding, displayName) {
     this.callbacks = callbacks;
+    this.binding = binding;
+    this.releaseCodes = new Set(getReleaseCodes(binding));
+    this.displayName = displayName;
   }
   start() {
     if (this.started) return;
-    const perms = iohook.checkAccessibilityPermissions();
-    if (!perms.hasPermissions) {
-      console.log(
-        "[FnHook] Accessibility permissions not granted. Requesting..."
-      );
-      iohook.requestAccessibilityPermissions();
-      throw new Error(
-        "Accessibility permissions required. Please grant access in System Preferences > Privacy & Security > Accessibility, then restart the app."
-      );
+    if (process.platform === "darwin") {
+      const trusted = systemPreferences.isTrustedAccessibilityClient(true);
+      if (!trusted) {
+        throw new Error(
+          "Accessibility permissions required. Please grant access in System Preferences > Privacy & Security > Accessibility, then restart the app."
+        );
+      }
     }
-    iohook.setEventFilter({
-      filterByEventType: true,
-      allowKeyboard: true,
-      allowMouse: false,
-      allowScroll: false
-    });
-    iohook.enablePerformanceMode();
-    iohook.on("flagsChanged", (event) => {
-      const fnNow = event.modifiers.fn;
-      if (fnNow && !this.fnDown) {
-        this.fnDown = true;
+    uIOhook.on("keydown", (e) => {
+      if (this.active) return;
+      if (e.keycode === this.binding.keycode && e.ctrlKey === this.binding.ctrl && e.shiftKey === this.binding.shift && e.altKey === this.binding.alt && e.metaKey === this.binding.meta) {
+        this.active = true;
         this.callbacks.onFnDown();
-      } else if (!fnNow && this.fnDown) {
-        this.fnDown = false;
+      }
+    });
+    uIOhook.on("keyup", (e) => {
+      if (!this.active) return;
+      if (this.releaseCodes.has(e.keycode)) {
+        this.active = false;
         this.callbacks.onFnUp();
       }
     });
-    iohook.startMonitoring();
+    uIOhook.start();
     this.started = true;
-    console.log("[FnHook] Started monitoring Fn key");
+    logger.info({ key: this.displayName }, "Started monitoring key");
   }
   stop() {
     if (!this.started) return;
-    iohook.stopMonitoring();
+    uIOhook.stop();
     this.started = false;
-    this.fnDown = false;
-    console.log("[FnHook] Stopped monitoring");
+    this.active = false;
+    logger.info("Stopped monitoring key");
   }
   get isFnDown() {
-    return this.fnDown;
+    return this.active;
+  }
+}
+const KEY_MAP = {
+  // Letters
+  a: UiohookKey.A,
+  b: UiohookKey.B,
+  c: UiohookKey.C,
+  d: UiohookKey.D,
+  e: UiohookKey.E,
+  f: UiohookKey.F,
+  g: UiohookKey.G,
+  h: UiohookKey.H,
+  i: UiohookKey.I,
+  j: UiohookKey.J,
+  k: UiohookKey.K,
+  l: UiohookKey.L,
+  m: UiohookKey.M,
+  n: UiohookKey.N,
+  o: UiohookKey.O,
+  p: UiohookKey.P,
+  q: UiohookKey.Q,
+  r: UiohookKey.R,
+  s: UiohookKey.S,
+  t: UiohookKey.T,
+  u: UiohookKey.U,
+  v: UiohookKey.V,
+  w: UiohookKey.W,
+  x: UiohookKey.X,
+  y: UiohookKey.Y,
+  z: UiohookKey.Z,
+  // Numbers
+  "0": UiohookKey[0],
+  "1": UiohookKey[1],
+  "2": UiohookKey[2],
+  "3": UiohookKey[3],
+  "4": UiohookKey[4],
+  "5": UiohookKey[5],
+  "6": UiohookKey[6],
+  "7": UiohookKey[7],
+  "8": UiohookKey[8],
+  "9": UiohookKey[9],
+  // Function keys
+  f1: UiohookKey.F1,
+  f2: UiohookKey.F2,
+  f3: UiohookKey.F3,
+  f4: UiohookKey.F4,
+  f5: UiohookKey.F5,
+  f6: UiohookKey.F6,
+  f7: UiohookKey.F7,
+  f8: UiohookKey.F8,
+  f9: UiohookKey.F9,
+  f10: UiohookKey.F10,
+  f11: UiohookKey.F11,
+  f12: UiohookKey.F12,
+  // Special keys
+  space: UiohookKey.Space,
+  enter: UiohookKey.Enter,
+  return: UiohookKey.Enter,
+  escape: UiohookKey.Escape,
+  esc: UiohookKey.Escape,
+  tab: UiohookKey.Tab,
+  backspace: UiohookKey.Backspace,
+  delete: UiohookKey.Delete,
+  insert: UiohookKey.Insert,
+  home: UiohookKey.Home,
+  end: UiohookKey.End,
+  pageup: UiohookKey.PageUp,
+  pagedown: UiohookKey.PageDown,
+  // Arrow keys
+  up: UiohookKey.ArrowUp,
+  down: UiohookKey.ArrowDown,
+  left: UiohookKey.ArrowLeft,
+  right: UiohookKey.ArrowRight,
+  arrowup: UiohookKey.ArrowUp,
+  arrowdown: UiohookKey.ArrowDown,
+  arrowleft: UiohookKey.ArrowLeft,
+  arrowright: UiohookKey.ArrowRight,
+  // Punctuation
+  semicolon: UiohookKey.Semicolon,
+  equal: UiohookKey.Equal,
+  comma: UiohookKey.Comma,
+  minus: UiohookKey.Minus,
+  period: UiohookKey.Period,
+  slash: UiohookKey.Slash,
+  backquote: UiohookKey.Backquote,
+  bracketleft: UiohookKey.BracketLeft,
+  backslash: UiohookKey.Backslash,
+  bracketright: UiohookKey.BracketRight,
+  quote: UiohookKey.Quote
+};
+function parseKeyBinding(keyStr) {
+  const parts = keyStr.toLowerCase().split("+").map((s) => s.trim());
+  if (parts.length === 0 || parts.some((p) => p === "")) {
+    throw new Error(`Invalid key binding: "${keyStr}"`);
+  }
+  let ctrl = false;
+  let shift = false;
+  let alt = false;
+  let meta = false;
+  let mainKey;
+  for (const part of parts) {
+    if (part === "ctrl" || part === "control") {
+      ctrl = true;
+    } else if (part === "shift") {
+      shift = true;
+    } else if (part === "alt" || part === "opt" || part === "option") {
+      alt = true;
+    } else if (part === "meta" || part === "cmd" || part === "command" || part === "super" || part === "win") {
+      meta = true;
+    } else {
+      if (mainKey !== void 0) {
+        throw new Error(`Multiple main keys in key binding: "${keyStr}"`);
+      }
+      mainKey = part;
+    }
+  }
+  if (mainKey === void 0) {
+    throw new Error(`No main key specified in key binding: "${keyStr}"`);
+  }
+  const keycode = KEY_MAP[mainKey];
+  if (keycode === void 0) {
+    throw new Error(`Unknown key "${mainKey}" in key binding: "${keyStr}"`);
+  }
+  return { keycode, ctrl, shift, alt, meta };
+}
+function formatKeyDisplay(binding) {
+  const isMac = process.platform === "darwin";
+  const parts = [];
+  if (binding.ctrl) parts.push(isMac ? "⌃" : "Ctrl");
+  if (binding.alt) parts.push(isMac ? "⌥" : "Alt");
+  if (binding.shift) parts.push(isMac ? "⇧" : "Shift");
+  if (binding.meta) parts.push(isMac ? "⌘" : "Win");
+  const keyName = Object.entries(KEY_MAP).find(([, v]) => v === binding.keycode)?.[0]?.toUpperCase() ?? "?";
+  parts.push(keyName);
+  return parts.join(isMac ? "" : "+");
+}
+const DEFAULT_KEY_STRING = "meta+shift+i";
+const DEFAULT_PROVIDER = "local";
+function defaultConfig() {
+  const binding = parseKeyBinding(DEFAULT_KEY_STRING);
+  return {
+    key: binding,
+    keyDisplay: formatKeyDisplay(binding),
+    provider: DEFAULT_PROVIDER
+  };
+}
+const configFileSchema = z.object({
+  key: z.string().refine(
+    (v) => {
+      try {
+        parseKeyBinding(v);
+        return true;
+      } catch {
+        return false;
+      }
+    },
+    { message: "Invalid key binding" }
+  ).optional().default(DEFAULT_KEY_STRING),
+  provider: z.enum(["local", "gemini", "openai"]).optional().default(DEFAULT_PROVIDER)
+});
+class ConfigError extends Error {
+  constructor(configPath, details) {
+    super(`Invalid config at ${configPath}:
+${details}`);
+    this.configPath = configPath;
+    this.details = details;
+    this.name = "ConfigError";
   }
 }
-let ai$1 = null;
-function getClient$1() {
-  if (ai$1) return ai$1;
+function loadConfig(cwd) {
+  const configPath = join(cwd, ".pi", "pi-voice.json");
+  let raw;
+  try {
+    raw = readFileSync(configPath, "utf-8");
+  } catch (err) {
+    if (err.code === "ENOENT") {
+      logger.info({ configPath }, "No config file found, using defaults");
+      return defaultConfig();
+    }
+    throw new ConfigError(configPath, `Failed to read file: ${err.message}`);
+  }
+  let json;
+  try {
+    json = JSON.parse(raw);
+  } catch {
+    throw new ConfigError(configPath, "Invalid JSON syntax");
+  }
+  const result = configFileSchema.safeParse(json);
+  if (!result.success) {
+    const details = result.error.issues.map((issue) => {
+      const path = issue.path.length > 0 ? `"${issue.path.join(".")}"` : "(root)";
+      return `  - ${path}: ${issue.message}`;
+    }).join("\n");
+    throw new ConfigError(configPath, details);
+  }
+  const parsed = result.data;
+  const binding = parseKeyBinding(parsed.key);
+  const display = formatKeyDisplay(binding);
+  logger.info({ key: display, provider: parsed.provider, configPath }, "Loaded config");
+  return { key: binding, keyDisplay: display, provider: parsed.provider };
+}
+const DEFAULT_MODEL = "medium-q5_0";
+const HF_BASE_URL = "https://huggingface.co/ggerganov/whisper.cpp/resolve/main";
+function modelCacheDir() {
+  return join(homedir(), ".pi-agent", "whisper");
+}
+function modelFileName(model) {
+  return `ggml-${model}.bin`;
+}
+async function downloadModel(model, destPath) {
+  const url = `${HF_BASE_URL}/${modelFileName(model)}`;
+  logger.info({ model, url }, "Downloading Whisper model");
+  const response = await fetch(url, { method: "GET", redirect: "follow" });
+  if (!response.ok) {
+    throw new Error(
+      `Failed to download Whisper model "${model}": HTTP ${response.status}`
+    );
+  }
+  const totalBytes = Number(response.headers.get("content-length") ?? 0);
+  const totalMB = totalBytes > 0 ? (totalBytes / 1024 / 1024).toFixed(0) : "?";
+  const tmpPath = destPath + ".tmp";
+  try {
+    const fileStream = createWriteStream(tmpPath);
+    let downloadedBytes = 0;
+    let lastPercent = -1;
+    const body = response.body;
+    if (!body) {
+      throw new Error("Response body is null");
+    }
+    const reader = body.getReader();
+    const progressStream = new ReadableStream({
+      async pull(controller) {
+        const { done, value } = await reader.read();
+        if (done) {
+          controller.close();
+          return;
+        }
+        downloadedBytes += value.byteLength;
+        const downloadedMB = (downloadedBytes / 1024 / 1024).toFixed(0);
+        if (totalBytes > 0) {
+          const percent = Math.floor(
+            downloadedBytes / totalBytes * 100
+          );
+          if (percent !== lastPercent) {
+            lastPercent = percent;
+            process.stderr.write(
+              `\r[Whisper] Downloading model "${model}"... ${percent}% (${downloadedMB}/${totalMB} MB)`
+            );
+          }
+        } else {
+          process.stderr.write(
+            `\r[Whisper] Downloading model "${model}"... ${downloadedMB} MB`
+          );
+        }
+        controller.enqueue(value);
+      }
+    });
+    await finished(
+      Readable.fromWeb(progressStream).pipe(fileStream)
+    );
+    process.stderr.write("\n");
+    const { renameSync } = await import("node:fs");
+    renameSync(tmpPath, destPath);
+    logger.info({ destPath }, "Whisper model saved");
+  } catch (err) {
+    try {
+      unlinkSync(tmpPath);
+    } catch {
+    }
+    throw err;
+  }
+}
+async function resolveModelPath() {
+  const envPath = process.env.WHISPER_MODEL_PATH;
+  if (envPath) {
+    if (!existsSync(envPath)) {
+      throw new Error(
+        `WHISPER_MODEL_PATH points to "${envPath}" but the file does not exist`
+      );
+    }
+    return envPath;
+  }
+  const model = process.env.WHISPER_MODEL ?? DEFAULT_MODEL;
+  const cacheDir = modelCacheDir();
+  const destPath = join(cacheDir, modelFileName(model));
+  if (existsSync(destPath)) {
+    return destPath;
+  }
+  mkdirSync(cacheDir, { recursive: true });
+  await downloadModel(model, destPath);
+  return destPath;
+}
+let geminiClient$1 = null;
+function getGeminiClient$1() {
+  if (geminiClient$1) return geminiClient$1;
   const project = process.env.GOOGLE_CLOUD_PROJECT;
   const location = process.env.GOOGLE_CLOUD_LOCATION ?? "us-central1";
   if (!project) {
     throw new Error("GOOGLE_CLOUD_PROJECT environment variable is required");
   }
-  ai$1 = new GoogleGenAI({ vertexai: true, project, location });
-  return ai$1;
+  geminiClient$1 = new GoogleGenAI({ vertexai: true, project, location });
+  return geminiClient$1;
+}
+let openaiClient$1 = null;
+function getOpenAIClient$1() {
+  if (openaiClient$1) return openaiClient$1;
+  const apiKey = process.env.OPENAI_API_KEY;
+  if (!apiKey) {
+    throw new Error("OPENAI_API_KEY environment variable is required");
+  }
+  openaiClient$1 = new OpenAI({ apiKey });
+  return openaiClient$1;
 }
-async function transcribe(audioBuffer) {
-  const client = getClient$1();
+let whisperInstance = null;
+let whisperInitPromise = null;
+async function getWhisperInstance() {
+  if (whisperInstance) return whisperInstance;
+  if (whisperInitPromise) return whisperInitPromise;
+  whisperInitPromise = (async () => {
+    const modelPath = await resolveModelPath();
+    logger.info({ modelPath }, "Loading Whisper model");
+    whisperInstance = new Whisper(modelPath);
+    logger.info("Whisper model loaded");
+    return whisperInstance;
+  })();
+  return whisperInitPromise;
+}
+async function transcribeGemini(audioBuffer) {
+  const client = getGeminiClient$1();
   const base64Audio = audioBuffer.toString("base64");
   const response = await client.models.generateContent({
     model: "gemini-2.5-flash",
@@ -91,26 +450,74 @@ async function transcribe(audioBuffer) {
       }
     ]
   });
-  const text = response.text?.trim() ?? "";
-  console.log(`[STT] Transcribed: "${text}"`);
+  return response.text?.trim() ?? "";
+}
+async function transcribeOpenAI(audioBuffer) {
+  const client = getOpenAIClient$1();
+  const file = await toFile(audioBuffer, "recording.webm");
+  const transcription = await client.audio.transcriptions.create({
+    model: "gpt-4o-mini-transcribe",
+    file
+  });
+  return transcription.text?.trim() ?? "";
+}
+async function transcribeLocal(samples) {
+  const whisper = await getWhisperInstance();
+  const params = new WhisperFullParams(WhisperSamplingStrategy.Greedy);
+  params.language = "auto";
+  params.printProgress = false;
+  params.printRealtime = false;
+  params.printTimestamps = false;
+  params.singleSegment = false;
+  params.noTimestamps = true;
+  return whisper.full(params, samples);
+}
+async function transcribe(audioData, provider = "local") {
+  let text;
+  switch (provider) {
+    case "local": {
+      const samples = new Float32Array(audioData);
+      text = await transcribeLocal(samples);
+      break;
+    }
+    case "openai":
+      text = await transcribeOpenAI(Buffer.from(audioData));
+      break;
+    case "gemini":
+    default:
+      text = await transcribeGemini(Buffer.from(audioData));
+      break;
+  }
+  logger.info({ provider, text }, "Transcribed");
   return text;
 }
-let ai = null;
-function getClient() {
-  if (ai) return ai;
+let geminiClient = null;
+function getGeminiClient() {
+  if (geminiClient) return geminiClient;
   const project = process.env.GOOGLE_CLOUD_PROJECT;
   const location = process.env.GOOGLE_CLOUD_LOCATION ?? "us-central1";
   if (!project) {
     throw new Error("GOOGLE_CLOUD_PROJECT environment variable is required");
   }
-  ai = new GoogleGenAI({ vertexai: true, project, location });
-  return ai;
+  geminiClient = new GoogleGenAI({ vertexai: true, project, location });
+  return geminiClient;
+}
+let openaiClient = null;
+function getOpenAIClient() {
+  if (openaiClient) return openaiClient;
+  const apiKey = process.env.OPENAI_API_KEY;
+  if (!apiKey) {
+    throw new Error("OPENAI_API_KEY environment variable is required");
+  }
+  openaiClient = new OpenAI({ apiKey });
+  return openaiClient;
 }
 const TTS_SAMPLE_RATE = 24e3;
 const TTS_CHANNELS = 1;
 const TTS_BITS_PER_SAMPLE = 16;
-async function* synthesizeStream(text) {
-  const client = getClient();
+const OPENAI_PCM_CHUNK_SIZE = TTS_SAMPLE_RATE * (TTS_BITS_PER_SAMPLE / 8) * TTS_CHANNELS * 0.1;
+async function* synthesizeStreamGemini(text) {
+  const client = getGeminiClient();
   const response = await client.models.generateContentStream({
     model: "gemini-2.5-flash-preview-tts",
     contents: [
@@ -159,10 +566,80 @@ async function* synthesizeStream(text) {
     totalBytes += leftover.length;
     yield leftover;
   }
-  console.log(
-    `[TTS] Streamed ${totalBytes} bytes of PCM audio for "${text.substring(0, 50)}..."`
+  logger.info(
+    { provider: "gemini", totalBytes, text: text.substring(0, 50) },
+    "Streamed PCM audio"
   );
 }
+async function* synthesizeStreamOpenAI(text) {
+  const client = getOpenAIClient();
+  const response = await client.audio.speech.create({
+    model: "gpt-4o-mini-tts",
+    voice: "alloy",
+    input: text,
+    response_format: "pcm"
+    // raw 24kHz 16-bit signed LE mono PCM
+  });
+  const arrayBuffer = await response.arrayBuffer();
+  const fullBuffer = Buffer.from(arrayBuffer);
+  let totalBytes = 0;
+  let offset = 0;
+  while (offset < fullBuffer.length) {
+    const end = Math.min(offset + OPENAI_PCM_CHUNK_SIZE, fullBuffer.length);
+    const chunk = fullBuffer.subarray(offset, end);
+    totalBytes += chunk.length;
+    yield chunk;
+    offset = end;
+  }
+  logger.info(
+    { provider: "openai", totalBytes, text: text.substring(0, 50) },
+    "Streamed PCM audio"
+  );
+}
+function speakLocal(text) {
+  return new Promise((resolve, reject) => {
+    if (process.platform !== "darwin") {
+      reject(new Error("Local TTS (say command) is only supported on macOS"));
+      return;
+    }
+    const voice = process.env.SAY_VOICE;
+    const args = [];
+    if (voice) {
+      args.push("-v", voice);
+    }
+    args.push(text);
+    const child = spawn("say", args, { stdio: "ignore" });
+    child.on("error", (err) => {
+      reject(new Error(`Failed to spawn say command: ${err.message}`));
+    });
+    child.on("close", (code) => {
+      if (code === 0) {
+        logger.info(
+          { provider: "local", text: text.substring(0, 50) },
+          "Spoke text"
+        );
+        resolve();
+      } else {
+        reject(new Error(`say command exited with code ${code}`));
+      }
+    });
+  });
+}
+async function* synthesizeStream(text, provider = "local") {
+  switch (provider) {
+    case "local":
+      throw new Error(
+        "Local TTS does not support PCM streaming. Use speakLocal() instead."
+      );
+    case "openai":
+      yield* synthesizeStreamOpenAI(text);
+      break;
+    case "gemini":
+    default:
+      yield* synthesizeStreamGemini(text);
+      break;
+  }
+}
 let session = null;
 let sessionCwd = process.cwd();
 function setSessionCwd(cwd) {
@@ -170,13 +647,13 @@ function setSessionCwd(cwd) {
 }
 async function getOrCreateSession() {
   if (session) return session;
-  console.log(`[PiSession] Creating new agent session (cwd: ${sessionCwd})...`);
+  logger.info({ cwd: sessionCwd }, "Creating new agent session");
   const result = await createAgentSession({
     cwd: sessionCwd,
     sessionManager: SessionManager.inMemory()
   });
   session = result.session;
-  console.log("[PiSession] Session created");
+  logger.info("Agent session created");
   return session;
 }
 async function prompt(text, options) {
@@ -185,7 +662,7 @@ async function prompt(text, options) {
     if (event.type === "message_update" && event.assistantMessageEvent.type === "text_end") {
       const content = event.assistantMessageEvent.content.trim();
       if (content.length > 0) {
-        console.log(`[PiSession] Response: ${content}`);
+        logger.info({ content }, "Agent response");
         options?.onTextEnd?.(content);
       }
     }
@@ -200,7 +677,7 @@ function dispose() {
   if (session) {
     session.dispose();
     session = null;
-    console.log("[PiSession] Session disposed");
+    logger.info("Agent session disposed");
   }
 }
 const IPC = {
@@ -210,8 +687,6 @@ const IPC = {
   PLAY_AUDIO_STREAM_START: "play-audio-stream-start",
   PLAY_AUDIO_STREAM_CHUNK: "play-audio-stream-chunk",
   PLAY_AUDIO_STREAM_END: "play-audio-stream-end",
-  STATE_CHANGED: "state-changed",
-  STATUS_MESSAGE: "status-message",
   // renderer -> main
   RECORDING_DATA: "recording-data",
   RECORDING_ERROR: "recording-error",
@@ -275,7 +750,7 @@ function startDaemonServer(handler) {
     });
   });
   server.listen(socketPath);
-  console.log(`[DaemonIPC] Listening on ${socketPath}`);
+  logger.info({ socketPath }, "DaemonIPC listening");
   return socketPath;
 }
 function stopDaemonServer() {
@@ -290,31 +765,24 @@ function stopDaemonServer() {
     } catch {
     }
   }
-  console.log("[DaemonIPC] Server stopped");
+  logger.info("DaemonIPC server stopped");
 }
 const workingCwd = process.env["PI_VOICE_CWD"] || process.cwd();
 let mainWindow = null;
 let fnHook = null;
 let currentState = "idle";
-let forceQuit = false;
 setSessionCwd(workingCwd);
 function setState(state, message) {
   currentState = state;
-  console.log(`[Main] State: ${state}${message ? ` - ${message}` : ""}`);
-  mainWindow?.webContents.send(IPC.STATE_CHANGED, state);
-  if (message) {
-    mainWindow?.webContents.send(IPC.STATUS_MESSAGE, message);
-  }
+  logger.info({ state, message }, "State changed");
 }
 function createWindow() {
   mainWindow = new BrowserWindow({
     width: 400,
     height: 300,
-    resizable: true,
-    alwaysOnTop: true,
-    titleBarStyle: "hiddenInset",
-    // Daemon-first: window starts hidden
+    // Hidden audio worker – never shown to user
     show: false,
+    skipTaskbar: true,
     webPreferences: {
       preload: fileURLToPath(
         new URL("../preload/index.cjs", import.meta.url)
@@ -332,80 +800,81 @@ function createWindow() {
       )
     );
   }
-  mainWindow.on("close", (e) => {
-    if (!forceQuit) {
-      e.preventDefault();
-      mainWindow?.hide();
-    }
-  });
   mainWindow.on("closed", () => {
     mainWindow = null;
   });
 }
-function showWindow() {
-  if (mainWindow) {
-    mainWindow.show();
-    mainWindow.focus();
-  } else {
-    createWindow();
-    mainWindow.once("ready-to-show", () => {
-      mainWindow.show();
-      mainWindow.focus();
-    });
-  }
-}
-function setupIpcHandlers() {
+function setupIpcHandlers(provider) {
   ipcMain.on(IPC.RECORDING_DATA, async (_event, data) => {
     if (currentState !== "recording") return;
-    const audioBuffer = Buffer.from(data);
-    if (audioBuffer.length < 1e3) {
-      console.log("[Main] Recording too short, ignoring");
+    if (data.byteLength < 1e3) {
+      logger.info("Recording too short, ignoring");
       setState("idle", "Recording too short");
       return;
     }
     try {
       setState("transcribing", "Transcribing...");
-      const text = await transcribe(audioBuffer);
+      const text = await transcribe(data, provider);
       if (!text) {
         setState("idle", "No speech detected");
         return;
       }
       setState("thinking", `Sent: "${text}"`);
-      let streamStarted = false;
-      let ttsChain = Promise.resolve();
-      await prompt(text, {
-        onTextEnd: (segment) => {
-          if (!streamStarted) {
-            streamStarted = true;
-            setState("speaking", "Generating speech...");
-            mainWindow?.webContents.send(IPC.PLAY_AUDIO_STREAM_START, {
-              sampleRate: TTS_SAMPLE_RATE,
-              channels: TTS_CHANNELS,
-              bitsPerSample: TTS_BITS_PER_SAMPLE
-            });
-          }
-          ttsChain = ttsChain.then(async () => {
-            for await (const pcmChunk of synthesizeStream(segment)) {
-              mainWindow?.webContents.send(
-                IPC.PLAY_AUDIO_STREAM_CHUNK,
-                pcmChunk.buffer.slice(
-                  pcmChunk.byteOffset,
-                  pcmChunk.byteOffset + pcmChunk.byteLength
-                )
-              );
+      if (provider === "local") {
+        let speakStarted = false;
+        let ttsChain = Promise.resolve();
+        await prompt(text, {
+          onTextEnd: (segment) => {
+            if (!speakStarted) {
+              speakStarted = true;
+              setState("speaking", "Speaking...");
             }
-          });
+            ttsChain = ttsChain.then(() => speakLocal(segment));
+          }
+        });
+        await ttsChain;
+        if (!speakStarted) {
+          setState("idle", "No response from pi");
+        } else {
+          setState("idle");
         }
-      });
-      await ttsChain;
-      if (streamStarted) {
-        mainWindow?.webContents.send(IPC.PLAY_AUDIO_STREAM_END);
       } else {
-        setState("idle", "No response from pi");
+        let streamStarted = false;
+        let ttsChain = Promise.resolve();
+        await prompt(text, {
+          onTextEnd: (segment) => {
+            if (!streamStarted) {
+              streamStarted = true;
+              setState("speaking", "Generating speech...");
+              mainWindow?.webContents.send(IPC.PLAY_AUDIO_STREAM_START, {
+                sampleRate: TTS_SAMPLE_RATE,
+                channels: TTS_CHANNELS,
+                bitsPerSample: TTS_BITS_PER_SAMPLE
+              });
+            }
+            ttsChain = ttsChain.then(async () => {
+              for await (const pcmChunk of synthesizeStream(segment, provider)) {
+                mainWindow?.webContents.send(
+                  IPC.PLAY_AUDIO_STREAM_CHUNK,
+                  pcmChunk.buffer.slice(
+                    pcmChunk.byteOffset,
+                    pcmChunk.byteOffset + pcmChunk.byteLength
+                  )
+                );
+              }
+            });
+          }
+        });
+        await ttsChain;
+        if (streamStarted) {
+          mainWindow?.webContents.send(IPC.PLAY_AUDIO_STREAM_END);
+        } else {
+          setState("idle", "No response from pi");
+        }
       }
     } catch (err) {
       const msg = err instanceof Error ? err.message : String(err);
-      console.error("[Main] Pipeline error:", msg);
+      logger.error({ err: msg }, "Pipeline error");
       setState("error", msg);
       setTimeout(() => {
         if (currentState === "error") setState("idle");
@@ -413,7 +882,7 @@ function setupIpcHandlers() {
     }
   });
   ipcMain.on(IPC.RECORDING_ERROR, (_event, error) => {
-    console.error("[Main] Recording error:", error);
+    logger.error({ err: error }, "Recording error");
     setState("error", error);
     setTimeout(() => {
       if (currentState === "error") setState("idle");
@@ -425,45 +894,37 @@ function setupIpcHandlers() {
     }
   });
 }
-function setupFnHook() {
-  fnHook = new FnHook({
-    onFnDown: () => {
-      if (currentState !== "idle") {
-        console.log(
-          `[Main] Fn pressed but state is ${currentState}, ignoring`
-        );
-        return;
+function setupFnHook(config) {
+  const recordingFormat = config.provider === "local" ? "pcm" : "webm";
+  fnHook = new FnHook(
+    {
+      onFnDown: () => {
+        if (currentState !== "idle") {
+          logger.info(
+            { key: config.keyDisplay, state: currentState },
+            "Key pressed but not idle, ignoring"
+          );
+          return;
+        }
+        setState("recording", "Recording...");
+        mainWindow?.webContents.send(IPC.START_RECORDING, recordingFormat);
+      },
+      onFnUp: () => {
+        if (currentState !== "recording") return;
+        mainWindow?.webContents.send(IPC.STOP_RECORDING);
       }
-      setState("recording", "Recording...");
-      mainWindow?.webContents.send(IPC.START_RECORDING);
     },
-    onFnUp: () => {
-      if (currentState !== "recording") return;
-      mainWindow?.webContents.send(IPC.STOP_RECORDING);
-    }
-  });
+    config.key,
+    config.keyDisplay
+  );
   try {
     fnHook.start();
   } catch (err) {
     const msg = err instanceof Error ? err.message : String(err);
-    console.error("[Main] FnHook error:", msg);
+    logger.error({ err: msg }, "FnHook error");
     setState("error", msg);
   }
 }
-function setupCsp() {
-  const isDev = !app.isPackaged && !!process.env["ELECTRON_RENDERER_URL"];
-  session$1.defaultSession.webRequest.onHeadersReceived(
-    (details, callback) => {
-      const csp = isDev ? "default-src 'self'; script-src 'self' 'unsafe-inline'; style-src 'self' 'unsafe-inline'; connect-src 'self' ws://localhost:* http://localhost:*; media-src 'self' blob:" : "default-src 'self'; style-src 'self' 'unsafe-inline'; media-src 'self' blob:";
-      callback({
-        responseHeaders: {
-          ...details.responseHeaders,
-          "Content-Security-Policy": [csp]
-        }
-      });
-    }
-  );
-}
 function handleDaemonCommand(command) {
   switch (command) {
     case "status":
@@ -474,12 +935,8 @@ function handleDaemonCommand(command) {
         pid: process.pid,
         uptime: process.uptime()
       };
-    case "show":
-      showWindow();
-      return { ok: true };
     case "stop":
       setImmediate(() => {
-        forceQuit = true;
         app.quit();
       });
       return { ok: true };
@@ -488,7 +945,7 @@ function handleDaemonCommand(command) {
   }
 }
 function gracefulShutdown() {
-  console.log("[Main] Shutting down...");
+  logger.info("Shutting down...");
   fnHook?.stop();
   dispose();
   stopDaemonServer();
@@ -496,33 +953,45 @@ function gracefulShutdown() {
 }
 process.on("SIGTERM", () => {
   gracefulShutdown();
-  forceQuit = true;
   app.quit();
 });
 const gotLock = app.requestSingleInstanceLock();
 if (!gotLock) {
-  console.log("[Main] Another instance is already running. Exiting.");
+  logger.warn("Another instance is already running. Exiting.");
   app.quit();
-} else {
-  app.on("second-instance", () => {
-    showWindow();
-  });
 }
-app.whenReady().then(() => {
-  setupCsp();
+app.whenReady().then(async () => {
+  let config;
+  try {
+    config = loadConfig(workingCwd);
+  } catch (err) {
+    if (err instanceof ConfigError) {
+      logger.error({ err: err.message }, "Config error");
+    } else {
+      logger.error({ err: err instanceof Error ? err.message : String(err) }, "Failed to load config");
+    }
+    app.quit();
+    return;
+  }
+  if (config.provider === "local") {
+    try {
+      await resolveModelPath();
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      logger.error({ err: msg }, "Failed to prepare Whisper model");
+      app.quit();
+      return;
+    }
+  }
   createWindow();
-  setupIpcHandlers();
-  setupFnHook();
+  setupIpcHandlers(config.provider);
+  setupFnHook(config);
   startDaemonServer(handleDaemonCommand);
   saveRuntimeState(workingCwd);
-  console.log(`[Main] pi-voice daemon started (cwd: ${workingCwd})`);
+  logger.info({ cwd: workingCwd }, "pi-voice daemon started");
 });
 app.on("window-all-closed", () => {
 });
-app.on("activate", () => {
-  showWindow();
-});
 app.on("before-quit", () => {
-  forceQuit = true;
   gracefulShutdown();
 });