opencode-voice-dictation 0.0.0-stage → 0.2.0

package/src/gui/engines/system-speech.ts

@@ -0,0 +1,202 @@
+import { spawn, type ChildProcess } from "node:child_process"
+import { createHash } from "node:crypto"
+import { mkdirSync, writeFileSync } from "node:fs"
+import { tmpdir } from "node:os"
+import { join } from "node:path"
+import type { DiagnoseResult } from "../contract"
+import { DICTATION_SCRIPT } from "./script"
+
+export interface EngineOptions {
+  locale: string
+  minConfidence: number
+}
+
+export interface EngineCallbacks {
+  onReady(locale: string): void
+  onFinal(text: string, confidence: number): void
+  onError(code: string, detail: string, available: string[]): void
+  onExit(code: number | null, detail: string): void
+}
+
+export interface EngineHandle {
+  stop(): void
+}
+
+interface EngineEvent {
+  type?: string
+  locale?: string
+  text?: string
+  confidence?: number
+  code?: string
+  detail?: string
+  available?: string[]
+}
+
+const POWERSHELL = "powershell.exe"
+
+function scriptFile(): string {
+  const dir = join(tmpdir(), "opencode-voice-dictation")
+  mkdirSync(dir, { recursive: true })
+  const hash = createHash("sha1").update(DICTATION_SCRIPT).digest("hex").slice(0, 12)
+  const file = join(dir, `dictation-${hash}.ps1`)
+  writeFileSync(file, DICTATION_SCRIPT, "utf8")
+  return file
+}
+
+function spawnPowershell(args: string[]): ChildProcess {
+  return spawn(POWERSHELL, args, {
+    windowsHide: true,
+    stdio: ["ignore", "pipe", "pipe"],
+  })
+}
+
+function killTree(child: ChildProcess) {
+  const pid = child.pid
+  if (pid === undefined) {
+    child.kill()
+    return
+  }
+  const killer = spawn("taskkill", ["/PID", String(pid), "/T", "/F"], {
+    windowsHide: true,
+    stdio: "ignore",
+  })
+  killer.on("error", () => child.kill())
+}
+
+export function startEngine(options: EngineOptions, callbacks: EngineCallbacks): EngineHandle {
+  const child = spawnPowershell([
+    "-NoProfile",
+    "-NonInteractive",
+    "-ExecutionPolicy",
+    "Bypass",
+    "-File",
+    scriptFile(),
+    "-Culture",
+    options.locale,
+    "-MinConfidence",
+    String(options.minConfidence),
+  ])
+
+  let stopped = false
+  let stderr = ""
+  let buffer = ""
+
+  const emit = (event: EngineEvent) => {
+    switch (event.type) {
+      case "ready":
+        callbacks.onReady(event.locale ?? options.locale)
+        break
+      case "final":
+        if (event.text) callbacks.onFinal(event.text, event.confidence ?? 0)
+        break
+      case "error":
+        callbacks.onError(event.code ?? "UNKNOWN", event.detail ?? "", event.available ?? [])
+        break
+    }
+  }
+
+  child.stdout?.setEncoding("utf8")
+  child.stdout?.on("data", (chunk: string) => {
+    buffer += chunk
+    let index = buffer.indexOf("\n")
+    while (index >= 0) {
+      const line = buffer.slice(0, index).replace(/\r$/, "").trim()
+      buffer = buffer.slice(index + 1)
+      if (line) {
+        try {
+          emit(JSON.parse(line) as EngineEvent)
+        } catch {
+          // A partial or unexpected line: ignore it and keep the stream alive.
+        }
+      }
+      index = buffer.indexOf("\n")
+    }
+  })
+
+  child.stderr?.setEncoding("utf8")
+  child.stderr?.on("data", (chunk: string) => {
+    stderr = (stderr + chunk).slice(-2000)
+  })
+
+  child.on("error", (cause) => {
+    if (stopped) return
+    callbacks.onError("ENGINE_START_FAILED", cause.message, [])
+  })
+
+  child.on("close", (code) => {
+    if (stopped) return
+    callbacks.onExit(code, stderr.trim().slice(-500))
+  })
+
+  return {
+    stop() {
+      stopped = true
+      killTree(child)
+    },
+  }
+}
+
+export function diagnose(): Promise<DiagnoseResult> {
+  return new Promise((resolve, reject) => {
+    const child = spawnPowershell([
+      "-NoProfile",
+      "-NonInteractive",
+      "-ExecutionPolicy",
+      "Bypass",
+      "-File",
+      scriptFile(),
+      "-Diagnose",
+    ])
+
+    let stdout = ""
+    let stderr = ""
+    let settled = false
+
+    const finish = (error: Error | undefined, value?: DiagnoseResult) => {
+      if (settled) return
+      settled = true
+      clearTimeout(timer)
+      if (error) reject(error)
+      else resolve(value as DiagnoseResult)
+    }
+
+    const timer = setTimeout(() => {
+      killTree(child)
+      finish(new Error("diagnose timed out"))
+    }, 20000)
+
+    child.stdout?.setEncoding("utf8")
+    child.stdout?.on("data", (chunk: string) => {
+      stdout += chunk
+    })
+    child.stderr?.setEncoding("utf8")
+    child.stderr?.on("data", (chunk: string) => {
+      stderr += chunk
+    })
+    child.on("error", (cause) => finish(cause))
+    child.on("close", () => {
+      const line = stdout
+        .split(/\r?\n/)
+        .map((entry) => entry.trim())
+        .filter((entry) => entry.startsWith("{"))
+        .at(-1)
+
+      if (!line) {
+        finish(new Error(stderr.trim() || "no output from PowerShell"))
+        return
+      }
+
+      try {
+        const parsed = JSON.parse(line) as DiagnoseResult
+        finish(undefined, {
+          locales: parsed.locales ?? [],
+          microphone: parsed.microphone === true,
+          selected: parsed.selected ?? "",
+          error: parsed.error ?? "",
+        })
+      } catch (cause) {
+        finish(cause instanceof Error ? cause : new Error(String(cause)))
+      }
+    })
+  })
+}

package/src/gui/engines/win-h.ts

@@ -0,0 +1,80 @@
+import { spawn, type ChildProcess } from "node:child_process"
+import { createHash } from "node:crypto"
+import { mkdirSync, writeFileSync } from "node:fs"
+import { tmpdir } from "node:os"
+import { join } from "node:path"
+
+/**
+ * Sends the Windows voice typing shortcut (Win+H).
+ *
+ * `SendKeys` cannot press the Windows key, so this uses `keybd_event` from
+ * user32.dll through an inline C# type compiled by `Add-Type`.
+ *
+ * Keep the script ASCII-only: Windows PowerShell 5.1 reads a BOM-less script
+ * as ANSI.
+ */
+export const WIN_H_SCRIPT = String.raw`$ErrorActionPreference = "Stop"
+
+Add-Type @"
+using System;
+using System.Runtime.InteropServices;
+
+public static class WinH {
+  [DllImport("user32.dll", SetLastError = true)]
+  public static extern void keybd_event(byte bVk, byte bScan, uint dwFlags, UIntPtr dwExtraInfo);
+
+  private const byte VK_LWIN = 0x5B;
+  private const byte VK_H = 0x48;
+  private const uint KEYUP = 0x0002;
+
+  public static void Send() {
+    keybd_event(VK_LWIN, 0, 0, UIntPtr.Zero);
+    System.Threading.Thread.Sleep(60);
+    keybd_event(VK_H, 0, 0, UIntPtr.Zero);
+    System.Threading.Thread.Sleep(60);
+    keybd_event(VK_H, 0, KEYUP, UIntPtr.Zero);
+    System.Threading.Thread.Sleep(60);
+    keybd_event(VK_LWIN, 0, KEYUP, UIntPtr.Zero);
+  }
+}
+"@
+
+[WinH]::Send()
+`
+
+const POWERSHELL = "powershell.exe"
+
+function scriptFile(): string {
+  const dir = join(tmpdir(), "opencode-voice-dictation")
+  mkdirSync(dir, { recursive: true })
+  const hash = createHash("sha1").update(WIN_H_SCRIPT).digest("hex").slice(0, 12)
+  const file = join(dir, `win-h-${hash}.ps1`)
+  writeFileSync(file, WIN_H_SCRIPT, "utf8")
+  return file
+}
+
+function spawnPowershell(args: string[]): ChildProcess {
+  return spawn(POWERSHELL, args, {
+    windowsHide: true,
+    stdio: "ignore",
+  })
+}
+
+export function sendVoiceTypingShortcut(): Promise<void> {
+  return new Promise((resolve, reject) => {
+    const child = spawnPowershell([
+      "-NoProfile",
+      "-NonInteractive",
+      "-ExecutionPolicy",
+      "Bypass",
+      "-File",
+      scriptFile(),
+    ])
+
+    child.on("error", (cause) => reject(cause))
+    child.on("close", (code) => {
+      if (code === 0) resolve()
+      else reject(new Error(`Win+H helper exited with code ${code ?? "unknown"}`))
+    })
+  })
+}

package/src/gui/main.ts

@@ -0,0 +1,150 @@
+import type { Plugin } from "@opencode/plugin/gui"
+import { Dictation, Speech, VoiceTyping } from "./contract"
+import { diagnose, startEngine, type EngineHandle } from "./engines/system-speech"
+import { listSapiVoices, speakSapi, type SpeakHandle } from "./engines/sapi-speech"
+import { sendVoiceTypingShortcut } from "./engines/win-h"
+
+type Status = "idle" | "starting" | "listening" | "error"
+
+/**
+ * Runs once in the Electron main process.
+ *
+ * One dictation runs at a time (there is one microphone); the window that
+ * starts it receives the transcript events.
+ */
+export const main: Plugin.MainSetup = (ctx) => {
+  let status: Status = "idle"
+  let error = ""
+  let locale = ""
+  let handle: EngineHandle | undefined
+  let stopping = false
+
+  const reset = () => {
+    handle = undefined
+    stopping = false
+  }
+
+  const dictation = ctx.provide(Dictation, {
+    state: () => ({ status, error, locale }),
+
+    start(input, caller) {
+      if (handle) {
+        stopping = true
+        handle.stop()
+        reset()
+      }
+
+      status = "starting"
+      error = ""
+      locale = input.locale
+      dictation.changed()
+
+      const target = caller.window
+
+      try {
+        handle = startEngine(
+          { locale: input.locale, minConfidence: input.minConfidence },
+          {
+            onReady(selected) {
+              status = "listening"
+              locale = selected
+              dictation.changed()
+            },
+            onFinal(text, confidence) {
+              dictation.emit("final", { text, confidence }, target)
+            },
+            onError(code, detail, available) {
+              status = "error"
+              error = code
+              dictation.changed()
+              dictation.emit("error", { code, detail, available }, target)
+            },
+            onExit(code, detail) {
+              if (stopping) {
+                reset()
+                status = "idle"
+                error = ""
+                locale = ""
+                dictation.changed()
+                return
+              }
+
+              reset()
+              if (status !== "error") {
+                status = "error"
+                error = code === null ? "ENGINE_EXIT" : `ENGINE_EXIT_${code}`
+                dictation.changed()
+                dictation.emit(
+                  "error",
+                  { code: "ENGINE_EXIT", detail: detail || (code === null ? "" : String(code)), available: [] },
+                  target,
+                )
+              }
+            },
+          },
+        )
+      } catch (cause) {
+        status = "error"
+        error = "ENGINE_START_FAILED"
+        dictation.changed()
+        throw cause
+      }
+    },
+
+    stop() {
+      if (handle) {
+        stopping = true
+        handle.stop()
+        reset()
+      }
+      status = "idle"
+      error = ""
+      locale = ""
+      dictation.changed()
+    },
+
+    diagnose() {
+      return diagnose()
+    },
+  })
+
+  let talking: SpeakHandle | undefined
+
+  const speech = ctx.provide(Speech, {
+    speak(input) {
+      talking?.stop()
+      talking = speakSapi(input, (ok) => {
+        talking = undefined
+        speech.emit("done", { ok })
+      })
+    },
+
+    stop() {
+      if (talking) {
+        talking.stop()
+        talking = undefined
+      }
+      speech.emit("done", { ok: true })
+    },
+
+    voices() {
+      return listSapiVoices()
+    },
+  })
+
+  ctx.provide(VoiceTyping, {
+    toggle() {
+      return sendVoiceTypingShortcut()
+    },
+  })
+
+  ctx.onCleanup(() => {
+    if (handle) {
+      stopping = true
+      handle.stop()
+      reset()
+    }
+    talking?.stop()
+    talking = undefined
+  })
+}