pi-voice 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License Copyright (c) 2026 Yuku Kotani
+
+Permission is hereby granted, free of
+charge, to any person obtaining a copy of this software and associated
+documentation files (the "Software"), to deal in the Software without
+restriction, including without limitation the rights to use, copy, modify, merge,
+publish, distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to the
+following conditions:
+
+The above copyright notice and this permission notice
+(including the next paragraph) shall be included in all copies or substantial
+portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF
+ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO
+EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
+OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

package/README.md

@@ -0,0 +1,78 @@
+# pi-voice
+
+## Setup
+
+```bash
+bun install
+bun run build
+bun link          # `pi-voice` コマンドをグローバルに登録
+```
+
+## CLI
+
+pi-voice は **daemon 型**のアプリケーションです。Docker と同じように、`start` でバックグラウンドに常駐し、CLI で操作します。起動時にウィンドウは表示されません。
+
+`status` / `stop` / `show` は Electron を起動せず、Unix socket 経由で daemon と通信して即応します。
+
+```bash
+# daemon をバックグラウンドで起動（ウィンドウは表示されない）
+pi-voice start
+
+# daemon の状態を確認（state・PID・uptime を表示）
+pi-voice status
+
+# ウィンドウを表示
+pi-voice show
+
+# daemon を停止（Fn キーも無効化）
+pi-voice stop
+```
+
+- `start` は引数なしのデフォルトコマンドです。既に起動中ならエラーで終了します。
+- `start` は事前に `bun run build` が必要です（`out/main/index.js` がなければエラー）。
+- ウィンドウを閉じても daemon はバックグラウンドで動作し続けます。完全に停止するには `stop` か Cmd+Q を使ってください。
+- 実行状態は `~/.pi-voice/runtime-state.json`、制御 socket は `~/.pi-voice/daemon.sock` に配置されます。
+
+### 開発モード
+
+```bash
+bun run dev:electron
+```
+
+HMR 付きの Vite dev server で renderer を配信しつつ Electron を起動します（開発時はウィンドウを閉じると終了します）。
+
+CLI 単体で実行する場合:
+
+```bash
+bun run dev:cli
+```
+
+## Build
+
+```bash
+bun run build
+```
+
+`out/` にプロダクションビルドを出力します。
+
+## Preview
+
+```bash
+bun run preview
+```
+
+ビルド済みの成果物で Electron を起動して動作確認します。
+
+## Distribution
+
+```bash
+bun run dist
+```
+
+`bun run build` + electron-builder で macOS 向けの dmg/zip を `release/` に生成します。
+
+パッケージングせずディレクトリ出力のみ（テスト用）:
+
+```bash
+bun run dist:dir
+```

package/bin/pi-voice

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+import "../out/cli/cli.js";

package/build/entitlements.mac.plist

@@ -0,0 +1,14 @@
+<?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>com.apple.security.cs.allow-jit</key>
+    <true/>
+    <key>com.apple.security.cs.allow-unsigned-executable-memory</key>
+    <true/>
+    <key>com.apple.security.device.audio-input</key>
+    <true/>
+    <key>com.apple.security.automation.apple-events</key>
+    <true/>
+</dict>
+</plist>

package/out/cli/cli.js

@@ -0,0 +1,265 @@
+// src/cli.ts
+import { resolve, join as join2 } from "node:path";
+import { existsSync as existsSync2 } from "node:fs";
+import { spawn } from "node:child_process";
+import { createRequire } from "node:module";
+
+// src/services/runtime-state.ts
+import { join } from "node:path";
+import { homedir } from "node:os";
+import {
+  readFileSync,
+  writeFileSync,
+  unlinkSync,
+  existsSync,
+  mkdirSync
+} from "node:fs";
+var STATE_DIR = join(homedir(), ".pi-voice");
+var STATE_FILE = join(STATE_DIR, "runtime-state.json");
+var SOCKET_FILE = join(STATE_DIR, "daemon.sock");
+function getSocketPath() {
+  ensureDir();
+  return SOCKET_FILE;
+}
+function ensureDir() {
+  if (!existsSync(STATE_DIR)) {
+    mkdirSync(STATE_DIR, { recursive: true });
+  }
+}
+function isProcessAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function readRuntimeState() {
+  if (!existsSync(STATE_FILE))
+    return null;
+  try {
+    const raw = readFileSync(STATE_FILE, "utf-8");
+    const state = JSON.parse(raw);
+    if (!isProcessAlive(state.pid)) {
+      removeRuntimeState();
+      return null;
+    }
+    return state;
+  } catch {
+    removeRuntimeState();
+    return null;
+  }
+}
+function removeRuntimeState() {
+  try {
+    if (existsSync(STATE_FILE))
+      unlinkSync(STATE_FILE);
+  } catch {}
+}
+
+// src/services/daemon-ipc.ts
+import { createServer, createConnection } from "node:net";
+function sendCommand(command, socketPath) {
+  const target = socketPath ?? getSocketPath();
+  return new Promise((resolve, reject) => {
+    const conn = createConnection(target);
+    let buffer = "";
+    const timeout = setTimeout(() => {
+      conn.destroy();
+      reject(new Error("Daemon did not respond within 5 seconds"));
+    }, 5000);
+    conn.on("connect", () => {
+      conn.write(JSON.stringify({ command }) + `
+`);
+    });
+    conn.on("data", (data) => {
+      buffer += data.toString();
+      const idx = buffer.indexOf(`
+`);
+      if (idx !== -1) {
+        clearTimeout(timeout);
+        const line = buffer.slice(0, idx);
+        conn.end();
+        try {
+          resolve(JSON.parse(line));
+        } catch {
+          reject(new Error(`Invalid response from daemon: ${line}`));
+        }
+      }
+    });
+    conn.on("error", (err) => {
+      clearTimeout(timeout);
+      reject(err);
+    });
+  });
+}
+
+// src/cli.ts
+function usage() {
+  console.log(`Usage: pi-voice <command>
+
+Commands:
+  start   Start the pi-voice daemon in the background (default)
+  status  Show daemon status (state, PID, uptime)
+  stop    Stop the running daemon
+  show    Bring the window to front`);
+  process.exit(0);
+}
+function parseCommand() {
+  const arg = process.argv[2];
+  if (!arg || arg === "start")
+    return "start";
+  if (arg === "status")
+    return "status";
+  if (arg === "stop")
+    return "stop";
+  if (arg === "show")
+    return "show";
+  if (arg === "--help" || arg === "-h")
+    usage();
+  console.error(`Unknown command: ${arg}`);
+  usage();
+}
+function findPackageRoot(dir) {
+  let current = resolve(dir);
+  while (true) {
+    if (existsSync2(join2(current, "package.json"))) {
+      return current;
+    }
+    const parent = resolve(current, "..");
+    if (parent === current) {
+      console.error("Could not find package root (no package.json found).");
+      process.exit(1);
+    }
+    current = parent;
+  }
+}
+function isDaemonRunning() {
+  return readRuntimeState() !== null;
+}
+function dieNotRunning() {
+  console.error("pi-voice daemon is not running. Use 'pi-voice start' first.");
+  process.exit(1);
+}
+async function cmdStatus() {
+  const state = readRuntimeState();
+  if (!state) {
+    console.log("not running");
+    return;
+  }
+  try {
+    const res = await sendCommand("status");
+    if (res.ok) {
+      const uptime = typeof res.uptime === "number" ? Math.floor(res.uptime) : "?";
+      console.log(`running: ${res.cwd} (pid: ${res.pid}, state: ${res.state}, uptime: ${uptime}s)`);
+    } else {
+      console.log(`running: ${state.cwd} (pid: ${state.pid}, since: ${state.startedAt})`);
+      console.log(`  (daemon responded with error: ${res.error})`);
+    }
+  } catch {
+    removeRuntimeState();
+    console.log("not running (stale state cleaned up)");
+  }
+}
+async function cmdStop() {
+  if (!isDaemonRunning()) {
+    console.log("pi-voice daemon is not running.");
+    process.exit(1);
+  }
+  try {
+    const res = await sendCommand("stop");
+    if (res.ok) {
+      console.log("Stopping pi-voice daemon...");
+    } else {
+      console.error(`Failed to stop daemon: ${res.error}`);
+      process.exit(1);
+    }
+  } catch {
+    const state = readRuntimeState();
+    if (state) {
+      try {
+        process.kill(state.pid, "SIGTERM");
+        console.log(`Stopping pi-voice daemon (pid: ${state.pid})...`);
+      } catch {
+        removeRuntimeState();
+        console.log("pi-voice daemon is not running (stale state cleaned up).");
+        process.exit(1);
+      }
+    }
+  }
+}
+async function cmdShow() {
+  if (!isDaemonRunning())
+    dieNotRunning();
+  try {
+    const res = await sendCommand("show");
+    if (res.ok) {
+      console.log("Showing pi-voice window...");
+    } else {
+      console.error(`Failed to show window: ${res.error}`);
+      process.exit(1);
+    }
+  } catch {
+    const state = readRuntimeState();
+    if (state) {
+      try {
+        process.kill(state.pid, "SIGUSR1");
+        console.log("Showing pi-voice window...");
+      } catch {
+        removeRuntimeState();
+        console.error("pi-voice daemon is not running (stale state cleaned up).");
+        process.exit(1);
+      }
+    } else {
+      dieNotRunning();
+    }
+  }
+}
+async function cmdStart() {
+  if (isDaemonRunning()) {
+    const state = readRuntimeState();
+    console.error(`pi-voice daemon is already running in ${state.cwd} (pid: ${state.pid}).`);
+    process.exit(1);
+  }
+  const cwd = process.cwd();
+  const projectRoot = findPackageRoot(import.meta.dirname);
+  let electronBin;
+  try {
+    const _require = createRequire(import.meta.url);
+    electronBin = _require("electron");
+  } catch {
+    console.error("Could not find electron binary. Is 'electron' installed?");
+    process.exit(1);
+  }
+  const mainEntry = join2(projectRoot, "out", "main", "index.js");
+  if (!existsSync2(mainEntry)) {
+    console.error("Electron main entry not found. Run 'bun run build' first.");
+    process.exit(1);
+  }
+  const child = spawn(electronBin, [mainEntry], {
+    cwd,
+    env: {
+      ...process.env,
+      PI_VOICE_CWD: cwd
+    },
+    detached: true,
+    stdio: "ignore"
+  });
+  child.unref();
+  console.log(`pi-voice daemon started (pid: ${child.pid}, cwd: ${cwd})`);
+}
+var command = parseCommand();
+switch (command) {
+  case "start":
+    await cmdStart();
+    break;
+  case "status":
+    await cmdStatus();
+    break;
+  case "stop":
+    await cmdStop();
+    break;
+  case "show":
+    await cmdShow();
+    break;
+}

package/out/main/index.js

@@ -0,0 +1,528 @@
+import { app, session as session$1, 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 { join } from "node:path";
+import { homedir } from "node:os";
+import { writeFileSync, existsSync, unlinkSync, mkdirSync } from "node:fs";
+import { createServer } from "node:net";
+class FnHook {
+  fnDown = false;
+  callbacks;
+  started = false;
+  constructor(callbacks) {
+    this.callbacks = callbacks;
+  }
+  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."
+      );
+    }
+    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;
+        this.callbacks.onFnDown();
+      } else if (!fnNow && this.fnDown) {
+        this.fnDown = false;
+        this.callbacks.onFnUp();
+      }
+    });
+    iohook.startMonitoring();
+    this.started = true;
+    console.log("[FnHook] Started monitoring Fn key");
+  }
+  stop() {
+    if (!this.started) return;
+    iohook.stopMonitoring();
+    this.started = false;
+    this.fnDown = false;
+    console.log("[FnHook] Stopped monitoring");
+  }
+  get isFnDown() {
+    return this.fnDown;
+  }
+}
+let ai$1 = null;
+function getClient$1() {
+  if (ai$1) return ai$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;
+}
+async function transcribe(audioBuffer) {
+  const client = getClient$1();
+  const base64Audio = audioBuffer.toString("base64");
+  const response = await client.models.generateContent({
+    model: "gemini-2.5-flash",
+    contents: [
+      {
+        role: "user",
+        parts: [
+          {
+            inlineData: {
+              mimeType: "audio/webm",
+              data: base64Audio
+            }
+          },
+          {
+            text: "Transcribe this audio exactly as spoken. Output only the transcription, nothing else. If the audio is in Japanese, output in Japanese. If the audio is silent or empty, output an empty string."
+          }
+        ]
+      }
+    ]
+  });
+  const text = response.text?.trim() ?? "";
+  console.log(`[STT] Transcribed: "${text}"`);
+  return text;
+}
+let ai = null;
+function getClient() {
+  if (ai) return ai;
+  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;
+}
+const TTS_SAMPLE_RATE = 24e3;
+const TTS_CHANNELS = 1;
+const TTS_BITS_PER_SAMPLE = 16;
+async function* synthesizeStream(text) {
+  const client = getClient();
+  const response = await client.models.generateContentStream({
+    model: "gemini-2.5-flash-preview-tts",
+    contents: [
+      {
+        role: "user",
+        parts: [{ text }]
+      }
+    ],
+    config: {
+      responseModalities: ["AUDIO"],
+      speechConfig: {
+        voiceConfig: {
+          prebuiltVoiceConfig: {
+            voiceName: "Aoede"
+          }
+        }
+      }
+    }
+  });
+  let totalBytes = 0;
+  let leftover = null;
+  for await (const chunk of response) {
+    const candidate = chunk.candidates?.[0];
+    const parts = candidate?.content?.parts;
+    if (!parts) continue;
+    for (const part of parts) {
+      if (!part.inlineData?.data) continue;
+      let pcm = Buffer.from(part.inlineData.data, "base64");
+      if (leftover) {
+        pcm = Buffer.concat([leftover, pcm]);
+        leftover = null;
+      }
+      const bytesPerSample = TTS_BITS_PER_SAMPLE / 8;
+      const remainder = pcm.length % bytesPerSample;
+      if (remainder !== 0) {
+        leftover = pcm.subarray(pcm.length - remainder);
+        pcm = pcm.subarray(0, pcm.length - remainder);
+      }
+      if (pcm.length > 0) {
+        totalBytes += pcm.length;
+        yield pcm;
+      }
+    }
+  }
+  if (leftover && leftover.length > 0) {
+    totalBytes += leftover.length;
+    yield leftover;
+  }
+  console.log(
+    `[TTS] Streamed ${totalBytes} bytes of PCM audio for "${text.substring(0, 50)}..."`
+  );
+}
+let session = null;
+let sessionCwd = process.cwd();
+function setSessionCwd(cwd) {
+  sessionCwd = cwd;
+}
+async function getOrCreateSession() {
+  if (session) return session;
+  console.log(`[PiSession] Creating new agent session (cwd: ${sessionCwd})...`);
+  const result = await createAgentSession({
+    cwd: sessionCwd,
+    sessionManager: SessionManager.inMemory()
+  });
+  session = result.session;
+  console.log("[PiSession] Session created");
+  return session;
+}
+async function prompt(text, options) {
+  const s = await getOrCreateSession();
+  const unsubscribe = s.subscribe((event) => {
+    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}`);
+        options?.onTextEnd?.(content);
+      }
+    }
+  });
+  try {
+    await s.prompt(text);
+  } finally {
+    unsubscribe();
+  }
+}
+function dispose() {
+  if (session) {
+    session.dispose();
+    session = null;
+    console.log("[PiSession] Session disposed");
+  }
+}
+const IPC = {
+  // main -> renderer
+  START_RECORDING: "start-recording",
+  STOP_RECORDING: "stop-recording",
+  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",
+  PLAYBACK_DONE: "playback-done"
+};
+const STATE_DIR = join(homedir(), ".pi-voice");
+const STATE_FILE = join(STATE_DIR, "runtime-state.json");
+const SOCKET_FILE = join(STATE_DIR, "daemon.sock");
+function getSocketPath() {
+  ensureDir();
+  return SOCKET_FILE;
+}
+function ensureDir() {
+  if (!existsSync(STATE_DIR)) {
+    mkdirSync(STATE_DIR, { recursive: true });
+  }
+}
+function saveRuntimeState(cwd) {
+  ensureDir();
+  const state = {
+    pid: process.pid,
+    cwd,
+    startedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  writeFileSync(STATE_FILE, JSON.stringify(state, null, 2));
+}
+function removeRuntimeState() {
+  try {
+    if (existsSync(STATE_FILE)) unlinkSync(STATE_FILE);
+  } catch {
+  }
+}
+let server = null;
+function startDaemonServer(handler) {
+  const socketPath = getSocketPath();
+  if (existsSync(socketPath)) {
+    try {
+      unlinkSync(socketPath);
+    } catch {
+    }
+  }
+  server = createServer((conn) => {
+    let buffer = "";
+    conn.on("data", async (data) => {
+      buffer += data.toString();
+      const lines = buffer.split("\n");
+      buffer = lines.pop();
+      for (const line of lines) {
+        if (!line.trim()) continue;
+        try {
+          const req = JSON.parse(line);
+          const res = await handler(req.command);
+          conn.write(JSON.stringify(res) + "\n");
+        } catch (err) {
+          const msg = err instanceof Error ? err.message : String(err);
+          conn.write(JSON.stringify({ ok: false, error: msg }) + "\n");
+        }
+      }
+    });
+    conn.on("error", () => {
+    });
+  });
+  server.listen(socketPath);
+  console.log(`[DaemonIPC] Listening on ${socketPath}`);
+  return socketPath;
+}
+function stopDaemonServer() {
+  if (server) {
+    server.close();
+    server = null;
+  }
+  const socketPath = getSocketPath();
+  if (existsSync(socketPath)) {
+    try {
+      unlinkSync(socketPath);
+    } catch {
+    }
+  }
+  console.log("[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);
+  }
+}
+function createWindow() {
+  mainWindow = new BrowserWindow({
+    width: 400,
+    height: 300,
+    resizable: true,
+    alwaysOnTop: true,
+    titleBarStyle: "hiddenInset",
+    // Daemon-first: window starts hidden
+    show: false,
+    webPreferences: {
+      preload: fileURLToPath(
+        new URL("../preload/index.cjs", import.meta.url)
+      ),
+      contextIsolation: true,
+      nodeIntegration: false
+    }
+  });
+  if (!app.isPackaged && process.env["ELECTRON_RENDERER_URL"]) {
+    mainWindow.loadURL(process.env["ELECTRON_RENDERER_URL"]);
+  } else {
+    mainWindow.loadFile(
+      fileURLToPath(
+        new URL("../renderer/index.html", import.meta.url)
+      )
+    );
+  }
+  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() {
+  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");
+      setState("idle", "Recording too short");
+      return;
+    }
+    try {
+      setState("transcribing", "Transcribing...");
+      const text = await transcribe(audioBuffer);
+      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
+                )
+              );
+            }
+          });
+        }
+      });
+      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);
+      setState("error", msg);
+      setTimeout(() => {
+        if (currentState === "error") setState("idle");
+      }, 3e3);
+    }
+  });
+  ipcMain.on(IPC.RECORDING_ERROR, (_event, error) => {
+    console.error("[Main] Recording error:", error);
+    setState("error", error);
+    setTimeout(() => {
+      if (currentState === "error") setState("idle");
+    }, 3e3);
+  });
+  ipcMain.on(IPC.PLAYBACK_DONE, () => {
+    if (currentState === "speaking") {
+      setState("idle");
+    }
+  });
+}
+function setupFnHook() {
+  fnHook = new FnHook({
+    onFnDown: () => {
+      if (currentState !== "idle") {
+        console.log(
+          `[Main] Fn pressed but state is ${currentState}, ignoring`
+        );
+        return;
+      }
+      setState("recording", "Recording...");
+      mainWindow?.webContents.send(IPC.START_RECORDING);
+    },
+    onFnUp: () => {
+      if (currentState !== "recording") return;
+      mainWindow?.webContents.send(IPC.STOP_RECORDING);
+    }
+  });
+  try {
+    fnHook.start();
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    console.error("[Main] FnHook error:", msg);
+    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":
+      return {
+        ok: true,
+        state: currentState,
+        cwd: workingCwd,
+        pid: process.pid,
+        uptime: process.uptime()
+      };
+    case "show":
+      showWindow();
+      return { ok: true };
+    case "stop":
+      setImmediate(() => {
+        forceQuit = true;
+        app.quit();
+      });
+      return { ok: true };
+    default:
+      return { ok: false, error: `Unknown command: ${command}` };
+  }
+}
+function gracefulShutdown() {
+  console.log("[Main] Shutting down...");
+  fnHook?.stop();
+  dispose();
+  stopDaemonServer();
+  removeRuntimeState();
+}
+process.on("SIGTERM", () => {
+  gracefulShutdown();
+  forceQuit = true;
+  app.quit();
+});
+const gotLock = app.requestSingleInstanceLock();
+if (!gotLock) {
+  console.log("[Main] Another instance is already running. Exiting.");
+  app.quit();
+} else {
+  app.on("second-instance", () => {
+    showWindow();
+  });
+}
+app.whenReady().then(() => {
+  setupCsp();
+  createWindow();
+  setupIpcHandlers();
+  setupFnHook();
+  startDaemonServer(handleDaemonCommand);
+  saveRuntimeState(workingCwd);
+  console.log(`[Main] pi-voice daemon started (cwd: ${workingCwd})`);
+});
+app.on("window-all-closed", () => {
+});
+app.on("activate", () => {
+  showWindow();
+});
+app.on("before-quit", () => {
+  forceQuit = true;
+  gracefulShutdown();
+});

package/out/preload/index.cjs

@@ -0,0 +1,55 @@
+"use strict";
+const electron = require("electron");
+const IPC = {
+  // main -> renderer
+  START_RECORDING: "start-recording",
+  STOP_RECORDING: "stop-recording",
+  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",
+  PLAYBACK_DONE: "playback-done"
+};
+const api = {
+  onStartRecording: (callback) => {
+    electron.ipcRenderer.on(IPC.START_RECORDING, () => callback());
+  },
+  onStopRecording: (callback) => {
+    electron.ipcRenderer.on(IPC.STOP_RECORDING, () => callback());
+  },
+  onPlayAudioStreamStart: (callback) => {
+    electron.ipcRenderer.on(
+      IPC.PLAY_AUDIO_STREAM_START,
+      (_event, meta) => callback(meta)
+    );
+  },
+  onPlayAudioStreamChunk: (callback) => {
+    electron.ipcRenderer.on(
+      IPC.PLAY_AUDIO_STREAM_CHUNK,
+      (_event, pcmData) => callback(pcmData)
+    );
+  },
+  onPlayAudioStreamEnd: (callback) => {
+    electron.ipcRenderer.on(IPC.PLAY_AUDIO_STREAM_END, () => callback());
+  },
+  onStateChanged: (callback) => {
+    electron.ipcRenderer.on(IPC.STATE_CHANGED, (_event, state) => callback(state));
+  },
+  onStatusMessage: (callback) => {
+    electron.ipcRenderer.on(IPC.STATUS_MESSAGE, (_event, message) => callback(message));
+  },
+  sendRecordingData: (data) => {
+    electron.ipcRenderer.send(IPC.RECORDING_DATA, data);
+  },
+  sendRecordingError: (error) => {
+    electron.ipcRenderer.send(IPC.RECORDING_ERROR, error);
+  },
+  sendPlaybackDone: () => {
+    electron.ipcRenderer.send(IPC.PLAYBACK_DONE);
+  }
+};
+electron.contextBridge.exposeInMainWorld("piVoice", api);

package/out/renderer/assets/index-dks-nI81.js

@@ -0,0 +1,162 @@
+const toggleOnUrl = "" + new URL("toggle_on-D9c1Kpa8.wav", import.meta.url).href;
+const toggleOffUrl = "" + new URL("toggle_off-DBeRrNFR.wav", import.meta.url).href;
+document.getElementById("indicator");
+const icon = document.getElementById("icon");
+const stateLabel = document.getElementById("stateLabel");
+const statusMessage = document.getElementById("statusMessage");
+let mediaRecorder = null;
+let audioChunks = [];
+let audioContext = null;
+function playSoundEffect(url) {
+  const audio = new Audio(url);
+  audio.play().catch((err) => {
+    console.error("Failed to play sound effect:", err);
+  });
+}
+const stateConfig = {
+  idle: { icon: "⏸", label: "IDLE", defaultMessage: "Hold Fn to speak" },
+  recording: {
+    icon: "🔴",
+    label: "RECORDING",
+    defaultMessage: "Listening..."
+  },
+  transcribing: {
+    icon: "🔄",
+    label: "TRANSCRIBING",
+    defaultMessage: "Converting speech to text..."
+  },
+  thinking: {
+    icon: "🧠",
+    label: "THINKING",
+    defaultMessage: "pi is thinking..."
+  },
+  speaking: {
+    icon: "🔊",
+    label: "SPEAKING",
+    defaultMessage: "Playing response..."
+  },
+  error: { icon: "⚠", label: "ERROR", defaultMessage: "An error occurred" }
+};
+window.piVoice.onStateChanged((state) => {
+  document.body.className = "";
+  document.body.classList.add(`state-${state}`);
+  const config = stateConfig[state];
+  if (config) {
+    icon.textContent = config.icon;
+    stateLabel.textContent = config.label;
+    statusMessage.textContent = config.defaultMessage;
+  }
+});
+window.piVoice.onStatusMessage((message) => {
+  statusMessage.textContent = message;
+});
+window.piVoice.onStartRecording(async () => {
+  playSoundEffect(toggleOnUrl);
+  try {
+    const stream = await navigator.mediaDevices.getUserMedia({ audio: true });
+    audioChunks = [];
+    mediaRecorder = new MediaRecorder(stream, {
+      mimeType: "audio/webm;codecs=opus"
+    });
+    mediaRecorder.ondataavailable = (event) => {
+      if (event.data.size > 0) {
+        audioChunks.push(event.data);
+      }
+    };
+    mediaRecorder.onstop = async () => {
+      stream.getTracks().forEach((track) => track.stop());
+      if (audioChunks.length === 0) {
+        window.piVoice.sendRecordingError("No audio data captured");
+        return;
+      }
+      const blob = new Blob(audioChunks, { type: "audio/webm" });
+      const arrayBuffer = await blob.arrayBuffer();
+      window.piVoice.sendRecordingData(arrayBuffer);
+    };
+    mediaRecorder.start(100);
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    window.piVoice.sendRecordingError(`Microphone access failed: ${msg}`);
+  }
+});
+window.piVoice.onStopRecording(() => {
+  playSoundEffect(toggleOffUrl);
+  if (mediaRecorder && mediaRecorder.state !== "inactive") {
+    mediaRecorder.stop();
+  }
+});
+let streamSampleRate = 24e3;
+let streamChannels = 1;
+let streamBitsPerSample = 16;
+let streamNextPlayTime = 0;
+let streamActiveSources = 0;
+let streamEnded = false;
+function stopStreamPlayback() {
+  streamActiveSources = 0;
+  streamEnded = false;
+  streamNextPlayTime = 0;
+}
+window.piVoice.onPlayAudioStreamStart((meta) => {
+  try {
+    if (!audioContext) {
+      audioContext = new AudioContext();
+    }
+    stopStreamPlayback();
+    streamSampleRate = meta.sampleRate;
+    streamChannels = meta.channels;
+    streamBitsPerSample = meta.bitsPerSample;
+    streamNextPlayTime = 0;
+    streamEnded = false;
+  } catch (err) {
+    console.error("Stream start error:", err);
+  }
+});
+window.piVoice.onPlayAudioStreamChunk((pcmData) => {
+  try {
+    if (!audioContext) {
+      audioContext = new AudioContext();
+    }
+    const raw = pcmData instanceof ArrayBuffer ? pcmData : new Uint8Array(pcmData).buffer;
+    const bytesPerSample = streamBitsPerSample / 8;
+    const sampleCount = raw.byteLength / bytesPerSample / streamChannels;
+    if (sampleCount <= 0) return;
+    const audioBuffer = audioContext.createBuffer(
+      streamChannels,
+      sampleCount,
+      streamSampleRate
+    );
+    const view = new DataView(raw);
+    for (let ch = 0; ch < streamChannels; ch++) {
+      const channelData = audioBuffer.getChannelData(ch);
+      for (let i = 0; i < sampleCount; i++) {
+        const byteOffset = (i * streamChannels + ch) * bytesPerSample;
+        const int16 = view.getInt16(byteOffset, true);
+        channelData[i] = int16 / 32768;
+      }
+    }
+    const source = audioContext.createBufferSource();
+    source.buffer = audioBuffer;
+    source.connect(audioContext.destination);
+    const now = audioContext.currentTime;
+    if (streamNextPlayTime < now) {
+      streamNextPlayTime = now;
+    }
+    source.start(streamNextPlayTime);
+    streamNextPlayTime += audioBuffer.duration;
+    streamActiveSources++;
+    source.onended = () => {
+      streamActiveSources--;
+      if (streamEnded && streamActiveSources <= 0) {
+        window.piVoice.sendPlaybackDone();
+      }
+    };
+  } catch (err) {
+    console.error("Stream chunk playback error:", err);
+  }
+});
+window.piVoice.onPlayAudioStreamEnd(() => {
+  streamEnded = true;
+  if (streamActiveSources <= 0) {
+    window.piVoice.sendPlaybackDone();
+  }
+});

package/out/renderer/index.html

@@ -0,0 +1,147 @@
+<!DOCTYPE html>
+<html lang="ja">
+<head>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <title>pi-voice</title>
+  <style>
+    * {
+      margin: 0;
+      padding: 0;
+      box-sizing: border-box;
+    }
+
+    body {
+      font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, sans-serif;
+      background: #1a1a2e;
+      color: #e0e0e0;
+      display: flex;
+      flex-direction: column;
+      align-items: center;
+      justify-content: center;
+      height: 100vh;
+      user-select: none;
+      -webkit-app-region: drag;
+      overflow: hidden;
+    }
+
+    .container {
+      display: flex;
+      flex-direction: column;
+      align-items: center;
+      gap: 24px;
+    }
+
+    .indicator {
+      width: 120px;
+      height: 120px;
+      border-radius: 50%;
+      background: #2a2a4a;
+      display: flex;
+      align-items: center;
+      justify-content: center;
+      transition: all 0.3s ease;
+      position: relative;
+    }
+
+    .indicator::after {
+      content: '';
+      position: absolute;
+      width: 100%;
+      height: 100%;
+      border-radius: 50%;
+      border: 3px solid transparent;
+      transition: all 0.3s ease;
+    }
+
+    /* State styles */
+    .state-idle .indicator {
+      background: #2a2a4a;
+    }
+
+    .state-recording .indicator {
+      background: #e74c3c;
+      box-shadow: 0 0 30px rgba(231, 76, 60, 0.5);
+      animation: pulse 1s ease-in-out infinite;
+    }
+
+    .state-transcribing .indicator {
+      background: #f39c12;
+      animation: spin 1.5s linear infinite;
+    }
+
+    .state-thinking .indicator {
+      background: #3498db;
+      animation: think 2s ease-in-out infinite;
+    }
+
+    .state-speaking .indicator {
+      background: #2ecc71;
+      animation: speak 0.5s ease-in-out infinite alternate;
+    }
+
+    .state-error .indicator {
+      background: #c0392b;
+    }
+
+    @keyframes pulse {
+      0%, 100% { transform: scale(1); }
+      50% { transform: scale(1.08); }
+    }
+
+    @keyframes spin {
+      from { transform: rotate(0deg); }
+      to { transform: rotate(360deg); }
+    }
+
+    @keyframes think {
+      0%, 100% { opacity: 1; }
+      50% { opacity: 0.5; }
+    }
+
+    @keyframes speak {
+      from { transform: scale(1); }
+      to { transform: scale(1.05); }
+    }
+
+    .icon {
+      font-size: 48px;
+      line-height: 1;
+    }
+
+    .state-label {
+      font-size: 16px;
+      font-weight: 600;
+      text-transform: uppercase;
+      letter-spacing: 2px;
+    }
+
+    .status-message {
+      font-size: 13px;
+      color: #888;
+      max-width: 300px;
+      text-align: center;
+      word-break: break-word;
+      min-height: 20px;
+    }
+
+    .hint {
+      font-size: 11px;
+      color: #555;
+      position: fixed;
+      bottom: 16px;
+    }
+  </style>
+  <script type="module" crossorigin src="./assets/index-dks-nI81.js"></script>
+</head>
+<body>
+  <div class="container" id="app">
+    <div class="indicator" id="indicator">
+      <span class="icon" id="icon">&#x23F8;</span>
+    </div>
+    <div class="state-label" id="stateLabel">IDLE</div>
+    <div class="status-message" id="statusMessage">Hold Fn to speak</div>
+  </div>
+  <div class="hint">Fn key: push-to-talk</div>
+</body>
+</html>

package/package.json

@@ -0,0 +1,49 @@
+{
+  "name": "pi-voice",
+  "version": "0.1.0",
+  "description": "Voice interface for pi coding agent",
+  "author": "Yuku Kotani",
+  "license": "MIT",
+  "type": "module",
+  "main": "./out/main/index.js",
+  "bin": {
+    "pi-voice": "./bin/pi-voice"
+  },
+  "files": [
+    "bin/",
+    "out/",
+    "build/"
+  ],
+  "scripts": {
+    "cli": "bun src/cli.ts",
+    "dev:electron": "electron-vite dev",
+    "dev:cli": "bun src/cli.ts",
+    "build": "bun run build:electron && bun run build:cli",
+    "build:electron": "electron-vite build",
+    "build:cli": "bun build src/cli.ts --outdir out/cli --target node --format esm --external electron",
+    "preview": "electron-vite preview",
+    "prepack": "bun run build",
+    "dist": "bun run build && electron-builder --mac --config",
+    "dist:dir": "bun run build && electron-builder --mac --dir --config",
+    "prepublish": "bun run build"
+  },
+  "devDependencies": {
+    "@types/bun": "latest",
+    "electron-vite": "^3.1.0",
+    "electron-builder": "^26.0.0"
+  },
+  "peerDependencies": {
+    "typescript": "^5"
+  },
+  "dependencies": {
+    "@google/genai": "^1.40.0",
+    "@mariozechner/pi-coding-agent": "^0.52.7",
+    "electron": "^40.2.1",
+    "iohook-macos": "^1.2.1"
+  },
+  "trustedDependencies": [
+    "electron",
+    "iohook-macos",
+    "protobufjs"
+  ]
+}