@daniel156161/prism 0.2.92 → 0.2.97

package/src/prism-extensions/core/voice-runtime.ts

@@ -1,322 +0,0 @@
-import * as fs from "node:fs"
-import * as os from "node:os"
-import * as path from "node:path"
-import { spawn, spawnSync, type ChildProcess } from "node:child_process"
-import { readSettings } from "./shared-config.js"
-import { ensureVoiceboxServiceRunning, stopVoiceboxService } from "./voicebox-service.js"
-import { isVoiceboxBackend, resolveVoiceboxConfig, streamSpeechWithVoicebox } from "./voicebox-client.js"
-
-export type VoiceMode = "off" | "on" | "input" | "output"
-
-export interface VoiceConfig {
-  wakeWord: string
-  sttCommand?: string
-  whisperModel?: string
-  ttsCommand?: string
-  piperModel?: string
-  audioPlayer?: string
-  loopCooldownMs: number
-}
-
-export interface VoiceRuntimeOptions {
-  env?: NodeJS.ProcessEnv
-  sendUserMessage: (message: string) => void | Promise<void>
-  notify?: (message: string, level?: string) => void
-  setStatus?: (value: string | undefined) => void
-  spawnProcess?: typeof spawn
-  spawnSyncProcess?: typeof spawnSync
-}
-
-export function parseVoiceMode(input: string): VoiceMode | undefined {
-  const value = String(input || "").trim().toLowerCase()
-  if (!value || value === "status") return undefined
-  if (["on", "full", "both", "all"].includes(value)) return "on"
-  if (["off", "disable", "disabled", "stop"].includes(value)) return "off"
-  if (["input", "in", "listen", "mic"].includes(value)) return "input"
-  if (["output", "out", "speak", "tts"].includes(value)) return "output"
-  return undefined
-}
-
-export function voiceStatus(mode: VoiceMode): string | undefined {
-  if (mode === "off") return undefined
-  if (mode === "on") return "🎙 voice:in+out"
-  return mode === "input" ? "🎙 voice:in" : "🔊 voice:out"
-}
-
-function nonEmpty(value: unknown): string | undefined {
-  return typeof value === "string" && value.trim() ? value.trim() : undefined
-}
-
-export function resolveVoiceConfig(env: NodeJS.ProcessEnv = process.env): VoiceConfig {
-  const settings = readSettings(undefined, env)?.voice ?? {}
-  return {
-    wakeWord: nonEmpty(env.PRISM_VOICE_WAKE_WORD) ?? nonEmpty(settings.wakeWord) ?? "prism",
-    sttCommand: nonEmpty(env.PRISM_VOICE_STT_COMMAND) ?? nonEmpty(settings.sttCommand),
-    whisperModel: nonEmpty(env.PRISM_VOICE_WHISPER_MODEL) ?? nonEmpty(settings.whisperModel),
-    ttsCommand: nonEmpty(env.PRISM_VOICE_TTS_COMMAND) ?? nonEmpty(settings.ttsCommand),
-    piperModel: nonEmpty(env.PRISM_VOICE_PIPER_MODEL) ?? nonEmpty(settings.piperModel),
-    audioPlayer: nonEmpty(env.PRISM_VOICE_AUDIO_PLAYER) ?? nonEmpty(settings.audioPlayer),
-    loopCooldownMs: Math.max(0, Number(env.PRISM_VOICE_LOOP_COOLDOWN_MS ?? settings.loopCooldownMs ?? 1500) || 1500),
-  }
-}
-
-export function stripWakeWord(transcript: string, wakeWord: string): string | undefined {
-  const text = transcript.replace(/\s+/g, " ").trim()
-  if (!text) return undefined
-  const escaped = wakeWord.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")
-  const match = text.match(new RegExp(`(?:^|\\b)(?:hey\\s+|ok\\s+|okay\\s+)?${escaped}\\b[:,;\\-]?\\s*(.*)$`, "iu"))
-  const command = match?.[1]?.trim()
-  return command || undefined
-}
-
-export function normalizeVoiceText(text: string): string {
-  return text.toLowerCase().replace(/[^\p{L}\p{N}]+/gu, " ").replace(/\s+/g, " ").trim()
-}
-
-export function shouldIgnoreTranscript(transcript: string, state: { isSpeaking: boolean; lastSpokenText?: string; lastSpokenAt?: number }, now = Date.now(), cooldownMs = 1500): boolean {
-  if (state.isSpeaking) return true
-  if (state.lastSpokenAt && now - state.lastSpokenAt < cooldownMs) return true
-  const heard = normalizeVoiceText(transcript)
-  const spoken = normalizeVoiceText(state.lastSpokenText ?? "")
-  if (!heard || !spoken) return false
-  return heard.length >= 12 && (spoken.includes(heard) || heard.includes(spoken.slice(0, Math.min(spoken.length, 160))))
-}
-
-function isThinkingTextBlock(block: any): boolean {
-  if (!block || typeof block !== "object") return false
-  const marker = String(block.type ?? block.kind ?? block.name ?? block.category ?? block.role ?? "").toLowerCase()
-  if (/thinking|reasoning|scratchpad|analysis/.test(marker)) return true
-  if (block.thinking || block.reasoning || block.isThinking || block.isReasoning) return true
-  const metadata = block.metadata ?? block.providerMetadata ?? block.experimental_providerMetadata
-  if (metadata && typeof metadata === "object") {
-    const metadataMarker = JSON.stringify(metadata).toLowerCase()
-    if (/thinking|reasoning|scratchpad|analysis/.test(metadataMarker)) return true
-  }
-  return false
-}
-
-function stripThinkingText(text: string): string {
-  return text
-    .replace(/<\s*(think|thinking|reasoning|analysis|scratchpad)\b[^>]*>[\s\S]*?<\s*\/\s*\1\s*>/giu, " ")
-    .replace(/^\s*(?:#{1,6}\s*)?(?:thinking|reasoning|analysis|scratchpad|internal notes?)\s*:?\s*$/gimu, " ")
-}
-
-export function messageToSpeechText(message: any, maxChars = 4000): string {
-  if (!message || message.role !== "assistant" || message.stopReason === "error") return ""
-  const content = message.content
-  if (Array.isArray(content) && content.some((block: any) => block?.type === "toolCall" || block?.type === "tool-call" || block?.toolCallId || block?.name && block?.arguments)) return ""
-  const text = Array.isArray(content)
-    ? content.filter((block: any) => block?.type === "text" && typeof block.text === "string" && !isThinkingTextBlock(block)).map((block: any) => block.text).join("\n")
-    : typeof content === "string" ? content : ""
-  return stripThinkingText(text)
-    .replace(/```[\s\S]*?```/g, "Code block omitted.")
-    .replace(/`([^`]+)`/g, "$1")
-    .replace(/\s+/g, " ")
-    .trim()
-    .slice(0, maxChars)
-}
-
-function commandExists(command: string, spawnSyncProcess: typeof spawnSync): boolean {
-  return spawnSyncProcess("sh", ["-lc", `command -v ${JSON.stringify(command)} >/dev/null 2>&1`], { stdio: "ignore" }).status === 0
-}
-
-function defaultSttCommand(config: VoiceConfig): string | undefined {
-  if (!config.whisperModel) return undefined
-  return `whisper-stream -m ${JSON.stringify(config.whisperModel)} --step 3000 --length 5000 --keep 500 -t 4`
-}
-
-function chooseAudioPlayer(config: VoiceConfig, spawnSyncProcess: typeof spawnSync): string | undefined {
-  if (config.audioPlayer) return config.audioPlayer
-  for (const candidate of ["paplay", "aplay", "ffplay"]) {
-    if (commandExists(candidate, spawnSyncProcess)) return candidate === "ffplay" ? "ffplay -nodisp -autoexit" : candidate
-  }
-  return undefined
-}
-
-export class LocalVoiceRuntime {
-  private mode: VoiceMode = "off"
-  private sttProcess?: ChildProcess
-  private isSpeaking = false
-  private lastSpokenText = ""
-  private lastSpokenAt = 0
-  private readonly env: NodeJS.ProcessEnv
-  private readonly spawnProcess: typeof spawn
-  private readonly spawnSyncProcess: typeof spawnSync
-
-  constructor(private readonly options: VoiceRuntimeOptions) {
-    this.env = options.env ?? process.env
-    this.spawnProcess = options.spawnProcess ?? spawn
-    this.spawnSyncProcess = options.spawnSyncProcess ?? spawnSync
-  }
-
-  getMode(): VoiceMode { return this.mode }
-
-  setMode(mode: VoiceMode): void {
-    this.mode = mode
-    this.options.setStatus?.(voiceStatus(mode))
-    if (mode === "on" || mode === "input") this.startInput()
-    else {
-      this.stopInput()
-      if (mode === "off") void this.stopVoicebox()
-    }
-  }
-
-  shutdown(): void {
-    this.stopInput()
-    void this.stopVoicebox()
-    this.options.setStatus?.(undefined)
-  }
-
-  async speakAssistantMessage(message: any): Promise<void> {
-    if (this.mode !== "on" && this.mode !== "output") return
-    const text = messageToSpeechText(message)
-    if (!text) return
-    await this.speak(text)
-  }
-
-  isVoiceboxEnabled(): boolean {
-    return isVoiceboxBackend(this.env)
-  }
-
-  async checkVoicebox(): Promise<boolean> {
-    if (!this.isVoiceboxEnabled()) return false
-    const { checkVoiceboxHealth } = await import("./voicebox-client.js")
-    return checkVoiceboxHealth(resolveVoiceboxConfig(this.env))
-  }
-
-  async ensureVoicebox(): Promise<boolean> {
-    if (!this.isVoiceboxEnabled()) return false
-    return ensureVoiceboxServiceRunning(this.env, this.spawnSyncProcess, this.options.notify)
-  }
-
-  async stopVoicebox(): Promise<boolean> {
-    if (!this.isVoiceboxEnabled()) return false
-    return stopVoiceboxService(this.env, this.spawnSyncProcess)
-  }
-
-  handleTranscript(rawTranscript: string): void {
-    if (this.mode !== "on" && this.mode !== "input") return
-    const config = resolveVoiceConfig(this.env)
-    if (shouldIgnoreTranscript(rawTranscript, { isSpeaking: this.isSpeaking, lastSpokenText: this.lastSpokenText, lastSpokenAt: this.lastSpokenAt }, Date.now(), config.loopCooldownMs)) return
-    const command = stripWakeWord(rawTranscript, config.wakeWord)
-    if (!command) return
-    void this.options.sendUserMessage(command)
-  }
-
-  private startInput(): void {
-    if (this.sttProcess) return
-    const config = resolveVoiceConfig(this.env)
-    const command = config.sttCommand ?? defaultSttCommand(config)
-    if (!command) {
-      this.options.notify?.("Voice input needs PRISM_VOICE_STT_COMMAND or PRISM_VOICE_WHISPER_MODEL (whisper.cpp whisper-stream).", "warning")
-      return
-    }
-
-    const child = this.spawnProcess(command, { shell: true, stdio: ["ignore", "pipe", "pipe"], env: this.env })
-    this.sttProcess = child
-    child.stdout?.setEncoding("utf-8")
-    child.stdout?.on("data", (chunk: string) => {
-      for (const line of String(chunk).split(/\r?\n/)) this.handleTranscript(line)
-    })
-    child.stderr?.setEncoding("utf-8")
-    child.stderr?.on("data", (chunk: string) => {
-      const line = String(chunk).split(/\r?\n/).find((value) => value.trim())
-      if (line && /error|failed|no such|cannot/i.test(line)) this.options.notify?.(`Voice input: ${line.trim()}`, "warning")
-    })
-    child.on("exit", () => {
-      if (this.sttProcess === child) this.sttProcess = undefined
-      if (this.mode === "on" || this.mode === "input") this.options.notify?.("Voice input stopped.", "warning")
-    })
-    this.options.notify?.(`Voice input listening for wake word “${config.wakeWord}”.`, "info")
-  }
-
-  private stopInput(): void {
-    const child = this.sttProcess
-    this.sttProcess = undefined
-    if (!child || child.killed) return
-    child.kill("SIGTERM")
-    setTimeout(() => { if (!child.killed) child.kill("SIGKILL") }, 1000).unref?.()
-  }
-
-  private async speak(text: string): Promise<void> {
-    const config = resolveVoiceConfig(this.env)
-    const command = config.ttsCommand
-    this.isSpeaking = true
-    this.lastSpokenText = text
-    try {
-      if (isVoiceboxBackend(this.env)) {
-        const ok = await this.ensureVoicebox()
-        if (!ok) {
-          this.options.notify?.("Voicebox is not reachable and could not be started.", "warning")
-          return
-        }
-        const player = chooseAudioPlayer(config, this.spawnSyncProcess)
-        if (!player) {
-          this.options.notify?.("Voicebox output needs an audio player: paplay, aplay, ffplay, or PRISM_VOICE_AUDIO_PLAYER.", "warning")
-          return
-        }
-        await this.streamVoiceboxToPlayer(text, player)
-        return
-      }
-      if (command) {
-        await this.runShell(command, text)
-        return
-      }
-      if (!config.piperModel) {
-        this.options.notify?.("Voice output needs PRISM_VOICE_TTS_COMMAND or PRISM_VOICE_PIPER_MODEL (Piper TTS).", "warning")
-        return
-      }
-      const player = chooseAudioPlayer(config, this.spawnSyncProcess)
-      if (!player) {
-        this.options.notify?.("Voice output needs an audio player: paplay, aplay, ffplay, or PRISM_VOICE_AUDIO_PLAYER.", "warning")
-        return
-      }
-      const wav = path.join(os.tmpdir(), `prism-voice-${process.pid}-${Date.now()}.wav`)
-      await this.runCommand("piper", ["--model", config.piperModel, "--output_file", wav], text)
-      await this.runShell(`${player} ${JSON.stringify(wav)}`, "")
-      fs.rmSync(wav, { force: true })
-    } finally {
-      this.lastSpokenAt = Date.now()
-      this.isSpeaking = false
-    }
-  }
-
-  private streamVoiceboxToPlayer(text: string, player: string): Promise<void> {
-    return new Promise((resolve) => {
-      const child = this.spawnProcess(player, { shell: true, stdio: ["pipe", "ignore", "pipe"], env: this.env })
-      let settled = false
-      const finish = () => {
-        if (settled) return
-        settled = true
-        resolve()
-      }
-      child.on("exit", finish)
-      child.on("error", finish)
-      streamSpeechWithVoicebox(text, (chunk) => {
-        if (!child.stdin?.writable) return
-        child.stdin.write(Buffer.from(chunk))
-      }, resolveVoiceboxConfig(this.env)).then(() => child.stdin?.end()).catch(() => {
-        child.stdin?.destroy()
-        finish()
-      })
-    })
-  }
-
-  private runShell(command: string, input: string): Promise<void> {
-    return new Promise((resolve) => {
-      const child = this.spawnProcess(command, { shell: true, stdio: ["pipe", "ignore", "pipe"], env: this.env })
-      child.stdin?.end(input)
-      child.on("exit", () => resolve())
-      child.on("error", () => resolve())
-    })
-  }
-
-  private runCommand(command: string, args: string[], input: string): Promise<void> {
-    return new Promise((resolve) => {
-      const child = this.spawnProcess(command, args, { stdio: ["pipe", "ignore", "pipe"], env: this.env })
-      child.stdin?.end(input)
-      child.on("exit", () => resolve())
-      child.on("error", () => resolve())
-    })
-  }
-}

package/src/prism-extensions/core/voicebox-client.ts

@@ -1,205 +0,0 @@
-import { readSettings } from "./shared-config.js"
-
-export interface VoiceboxConfig {
-  baseUrl: string
-  profile?: string
-  language: string
-  engine?: string
-  personality?: boolean
-  clientId: string
-  timeoutMs: number
-  generationTimeoutMs: number
-}
-
-export interface VoiceboxGenerationStatus {
-  id: string
-  status: string
-  duration?: number
-  error?: string | null
-  source?: string
-}
-
-function nonEmpty(value: unknown): string | undefined {
-  return typeof value === "string" && value.trim() ? value.trim() : undefined
-}
-
-function boolSetting(value: unknown): boolean | undefined {
-  if (typeof value === "boolean") return value
-  if (typeof value === "string" && /^(1|true|yes|on)$/i.test(value.trim())) return true
-  if (typeof value === "string" && /^(0|false|no|off)$/i.test(value.trim())) return false
-  return undefined
-}
-
-function numberSetting(value: unknown): number | undefined {
-  if (typeof value === "number" && Number.isFinite(value)) return value
-  if (typeof value === "string" && value.trim()) {
-    const parsed = Number(value)
-    if (Number.isFinite(parsed)) return parsed
-  }
-  return undefined
-}
-
-function getVoiceboxSettings(env: NodeJS.ProcessEnv): any {
-  const settings = readSettings(undefined, env)
-  return settings?.voicebox ?? settings?.voice?.voicebox ?? {}
-}
-
-function getVoiceSettings(env: NodeJS.ProcessEnv): any {
-  return readSettings(undefined, env)?.voice ?? {}
-}
-
-export function normalizeVoiceboxBaseUrl(value: string): string {
-  return value.replace(/\/+$/, "")
-}
-
-export function resolveVoiceboxConfig(env: NodeJS.ProcessEnv = process.env): VoiceboxConfig {
-  const voicebox = getVoiceboxSettings(env)
-  return {
-    baseUrl: normalizeVoiceboxBaseUrl(nonEmpty(env.PRISM_VOICEBOX_URL) ?? nonEmpty(voicebox.url) ?? nonEmpty(voicebox.baseUrl) ?? "http://127.0.0.1:17493"),
-    profile: nonEmpty(env.PRISM_VOICEBOX_PROFILE) ?? nonEmpty(voicebox.profile),
-    language: nonEmpty(env.PRISM_VOICEBOX_LANGUAGE) ?? nonEmpty(voicebox.language) ?? "en",
-    engine: nonEmpty(env.PRISM_VOICEBOX_ENGINE) ?? nonEmpty(voicebox.engine),
-    personality: boolSetting(env.PRISM_VOICEBOX_PERSONALITY) ?? boolSetting(voicebox.personality) ?? false,
-    clientId: nonEmpty(env.PRISM_VOICEBOX_CLIENT_ID) ?? nonEmpty(voicebox.clientId) ?? "prism",
-    timeoutMs: Math.max(1_000, numberSetting(env.PRISM_VOICEBOX_TIMEOUT_MS) ?? numberSetting(voicebox.timeoutMs) ?? 30_000),
-    generationTimeoutMs: Math.max(1_000, numberSetting(env.PRISM_VOICEBOX_GENERATION_TIMEOUT_MS) ?? numberSetting(voicebox.generationTimeoutMs) ?? 180_000),
-  }
-}
-
-export function resolveVoiceBackend(env: NodeJS.ProcessEnv = process.env): string | undefined {
-  return nonEmpty(env.PRISM_VOICE_BACKEND) ?? nonEmpty(getVoiceSettings(env).backend)
-}
-
-export function isVoiceboxBackend(env: NodeJS.ProcessEnv = process.env): boolean {
-  return /^(voicebox|auto)$/i.test(resolveVoiceBackend(env) ?? "") || !!nonEmpty(env.PRISM_VOICEBOX_URL) || !!nonEmpty(getVoiceboxSettings(env).url) || !!nonEmpty(getVoiceboxSettings(env).baseUrl)
-}
-
-async function fetchJson(url: string, init: RequestInit, timeoutMs: number): Promise<any> {
-  const response = await fetch(url, { ...init, signal: AbortSignal.timeout(timeoutMs) })
-  const text = await response.text()
-  const parsed = parseJsonOrText(text)
-  if (!response.ok) {
-    const detail = typeof parsed?.detail === "string" ? parsed.detail : typeof parsed === "string" ? parsed : `HTTP ${response.status}`
-    throw new Error(detail)
-  }
-  return parsed
-}
-
-async function fetchBuffer(url: string, init: RequestInit, timeoutMs: number): Promise<Buffer> {
-  const response = await fetch(url, { ...init, signal: AbortSignal.timeout(timeoutMs) })
-  if (!response.ok) throw new Error(`HTTP ${response.status}`)
-  return Buffer.from(await response.arrayBuffer())
-}
-
-async function fetchStream(url: string, init: RequestInit, timeoutMs: number, onChunk: (chunk: Uint8Array) => void | Promise<void>): Promise<void> {
-  const response = await fetch(url, { ...init, signal: AbortSignal.timeout(timeoutMs) })
-  if (!response.ok) throw new Error(`HTTP ${response.status}`)
-  if (!response.body) return
-  const reader = response.body.getReader()
-  try {
-    while (true) {
-      const { done, value } = await reader.read()
-      if (done) break
-      if (value?.byteLength) await onChunk(value)
-    }
-  } finally {
-    reader.releaseLock()
-  }
-}
-
-function parseJsonOrText(text: string): any {
-  try { return text ? JSON.parse(text) : undefined } catch { return text }
-}
-
-function parseVoiceboxStatusEvent(text: string): VoiceboxGenerationStatus | undefined {
-  for (const line of text.split(/\r?\n/)) {
-    if (!line.startsWith("data:")) continue
-    const parsed = parseJsonOrText(line.replace(/^data:\s*/, ""))
-    if (parsed && typeof parsed === "object" && typeof parsed.status === "string") return parsed
-  }
-  const parsed = parseJsonOrText(text)
-  if (parsed && typeof parsed === "object" && typeof parsed.status === "string") return parsed
-  return undefined
-}
-
-export async function checkVoiceboxHealth(config = resolveVoiceboxConfig()): Promise<boolean> {
-  try {
-    await fetchJson(`${config.baseUrl}/health`, { method: "GET" }, Math.min(config.timeoutMs, 5_000))
-    return true
-  } catch {
-    return false
-  }
-}
-
-export async function speakWithVoicebox(text: string, config = resolveVoiceboxConfig()): Promise<any> {
-  return fetchJson(`${config.baseUrl}/speak`, {
-    method: "POST",
-    headers: {
-      "Content-Type": "application/json",
-      "X-Voicebox-Client-Id": config.clientId,
-    },
-    body: JSON.stringify({
-      text,
-      profile: config.profile,
-      language: config.language,
-      engine: config.engine,
-      personality: config.personality,
-    }),
-  }, config.timeoutMs)
-}
-
-function isAbortLikeError(error: unknown): boolean {
-  return error instanceof Error && (error.name === "AbortError" || error.name === "TimeoutError")
-}
-
-export async function waitForVoiceboxGeneration(id: string, config = resolveVoiceboxConfig()): Promise<VoiceboxGenerationStatus> {
-  const deadline = Date.now() + config.generationTimeoutMs
-  let lastStatus: VoiceboxGenerationStatus | undefined
-  while (Date.now() < deadline) {
-    try {
-      const response = await fetch(`${config.baseUrl}/generate/${encodeURIComponent(id)}/status`, { method: "GET", signal: AbortSignal.timeout(Math.min(config.timeoutMs, 10_000)) })
-      const text = await response.text()
-      if (!response.ok) throw new Error(`HTTP ${response.status}`)
-      lastStatus = parseVoiceboxStatusEvent(text) ?? lastStatus
-      if (lastStatus?.status === "completed") return lastStatus
-      if (lastStatus?.status === "failed") throw new Error(lastStatus.error || "Voicebox generation failed")
-    } catch (error) {
-      if (!isAbortLikeError(error)) throw error
-      // Voicebox can block status responses while lazily loading a TTS model.
-      // Treat individual poll timeouts as transient; the overall generation
-      // timeout below remains the hard limit.
-    }
-    await new Promise((resolve) => setTimeout(resolve, 500))
-  }
-  throw new Error(`Voicebox generation timed out${lastStatus?.status ? ` (${lastStatus.status})` : ""}`)
-}
-
-export async function downloadVoiceboxAudio(id: string, config = resolveVoiceboxConfig()): Promise<Buffer> {
-  return fetchBuffer(`${config.baseUrl}/audio/${encodeURIComponent(id)}`, { method: "GET" }, config.timeoutMs)
-}
-
-export async function synthesizeSpeechWithVoicebox(text: string, config = resolveVoiceboxConfig()): Promise<Buffer> {
-  const generation = await speakWithVoicebox(text, config)
-  const id = String(generation?.id ?? "")
-  if (!id) throw new Error("Voicebox did not return a generation id")
-  await waitForVoiceboxGeneration(id, config)
-  return downloadVoiceboxAudio(id, config)
-}
-
-export async function streamSpeechWithVoicebox(text: string, onChunk: (chunk: Uint8Array) => void | Promise<void>, config = resolveVoiceboxConfig()): Promise<void> {
-  const generation = await speakWithVoicebox(text, config)
-  const id = String(generation?.id ?? "")
-  if (!id) throw new Error("Voicebox did not return a generation id")
-  await waitForVoiceboxGeneration(id, config)
-  await fetchStream(`${config.baseUrl}/audio/${encodeURIComponent(id)}`, { method: "GET" }, config.timeoutMs, onChunk)
-}
-
-export async function transcribeWithVoicebox(audio: Blob | Buffer | Uint8Array, options: { fileName?: string; language?: string; model?: string } = {}, config = resolveVoiceboxConfig()): Promise<string> {
-  const form = new FormData()
-  const file = audio instanceof Blob ? audio : new Blob([new Uint8Array(audio)])
-  form.append("file", file, options.fileName ?? "audio.wav")
-  if (options.language) form.append("language", options.language)
-  if (options.model) form.append("model", options.model)
-  const result = await fetchJson(`${config.baseUrl}/transcribe`, { method: "POST", body: form }, config.timeoutMs)
-  return String(result?.text ?? "")
-}

package/src/prism-extensions/core/voicebox-service.ts

@@ -1,137 +0,0 @@
-import * as fs from "node:fs"
-import * as os from "node:os"
-import * as path from "node:path"
-import { spawnSync, type SpawnSyncReturns } from "node:child_process"
-import { readSettings } from "./shared-config.js"
-import { checkVoiceboxHealth, resolveVoiceboxConfig } from "./voicebox-client.js"
-
-const VOICEBOX_REPO_URL = "https://github.com/jamiepine/voicebox.git"
-
-export interface VoiceboxServiceConfig {
-  autoInstall: boolean
-  autoStart: boolean
-  autoStop: boolean
-  installDir: string
-  installCommand: string
-  startCommand: string
-  stopCommand: string
-  startupTimeoutMs: number
-  installTimeoutMs: number
-  stopTimeoutMs: number
-}
-
-function nonEmpty(value: unknown): string | undefined {
-  return typeof value === "string" && value.trim() ? value.trim() : undefined
-}
-
-function boolSetting(value: unknown): boolean | undefined {
-  if (typeof value === "boolean") return value
-  if (typeof value === "string" && /^(1|true|yes|on)$/i.test(value.trim())) return true
-  if (typeof value === "string" && /^(0|false|no|off)$/i.test(value.trim())) return false
-  return undefined
-}
-
-function numberSetting(value: unknown): number | undefined {
-  if (typeof value === "number" && Number.isFinite(value)) return value
-  if (typeof value === "string" && value.trim()) {
-    const parsed = Number(value)
-    if (Number.isFinite(parsed)) return parsed
-  }
-  return undefined
-}
-
-function quote(value: string): string {
-  return JSON.stringify(value)
-}
-
-function defaultInstallDir(env: NodeJS.ProcessEnv): string {
-  return nonEmpty(env.PRISM_VOICEBOX_DIR) ?? path.join(os.homedir(), ".local", "share", "prism", "voicebox")
-}
-
-function defaultInstallCommand(installDir: string): string {
-  return `mkdir -p ${quote(path.dirname(installDir))} && git clone ${quote(VOICEBOX_REPO_URL)} ${quote(installDir)}`
-}
-
-function defaultStartCommand(installDir: string): string {
-  return `if command -v prism-voicebox >/dev/null 2>&1; then prism-voicebox start; else cd ${quote(installDir)} && docker compose up -d --build; fi`
-}
-
-function defaultStopCommand(installDir: string): string {
-  return `if command -v prism-voicebox >/dev/null 2>&1; then prism-voicebox stop; else cd ${quote(installDir)} && docker compose down; fi`
-}
-
-export function resolveVoiceboxServiceConfig(env: NodeJS.ProcessEnv = process.env): VoiceboxServiceConfig {
-  const settings = readSettings(undefined, env)?.voicebox ?? {}
-  const installDir = nonEmpty(env.PRISM_VOICEBOX_DIR) ?? nonEmpty(settings.installDir) ?? defaultInstallDir(env)
-  return {
-    autoInstall: boolSetting(env.PRISM_VOICEBOX_AUTO_INSTALL) ?? boolSetting(settings.autoInstall) ?? true,
-    autoStart: boolSetting(env.PRISM_VOICEBOX_AUTO_START) ?? boolSetting(settings.autoStart) ?? true,
-    autoStop: boolSetting(env.PRISM_VOICEBOX_AUTO_STOP) ?? boolSetting(settings.autoStop) ?? true,
-    installDir,
-    installCommand: nonEmpty(env.PRISM_VOICEBOX_INSTALL_COMMAND) ?? nonEmpty(settings.installCommand) ?? defaultInstallCommand(installDir),
-    startCommand: nonEmpty(env.PRISM_VOICEBOX_START_COMMAND) ?? nonEmpty(settings.startCommand) ?? defaultStartCommand(installDir),
-    stopCommand: nonEmpty(env.PRISM_VOICEBOX_STOP_COMMAND) ?? nonEmpty(settings.stopCommand) ?? defaultStopCommand(installDir),
-    startupTimeoutMs: Math.max(1_000, numberSetting(env.PRISM_VOICEBOX_STARTUP_TIMEOUT_MS) ?? numberSetting(settings.startupTimeoutMs) ?? 120_000),
-    installTimeoutMs: Math.max(1_000, numberSetting(env.PRISM_VOICEBOX_INSTALL_TIMEOUT_MS) ?? numberSetting(settings.installTimeoutMs) ?? 300_000),
-    stopTimeoutMs: Math.max(1_000, numberSetting(env.PRISM_VOICEBOX_STOP_TIMEOUT_MS) ?? numberSetting(settings.stopTimeoutMs) ?? 60_000),
-  }
-}
-
-async function sleep(ms: number): Promise<void> {
-  await new Promise((resolve) => setTimeout(resolve, ms))
-}
-
-function runShell(command: string, timeoutMs: number, env: NodeJS.ProcessEnv, spawnSyncProcess: typeof spawnSync): boolean {
-  const result: SpawnSyncReturns<Buffer> = spawnSyncProcess("sh", ["-lc", command], { env, stdio: "ignore", timeout: timeoutMs })
-  return !result.error && (result.status === 0 || result.status === null)
-}
-
-export function isVoiceboxServiceInstalled(env: NodeJS.ProcessEnv = process.env): boolean {
-  const service = resolveVoiceboxServiceConfig(env)
-  return fs.existsSync(path.join(service.installDir, "docker-compose.yml")) || fs.existsSync(path.join(service.installDir, "compose.yml"))
-}
-
-export async function installVoiceboxService(env: NodeJS.ProcessEnv = process.env, spawnSyncProcess: typeof spawnSync = spawnSync): Promise<boolean> {
-  const service = resolveVoiceboxServiceConfig(env)
-  if (isVoiceboxServiceInstalled(env)) return true
-  if (!service.autoInstall) return false
-  return runShell(service.installCommand, service.installTimeoutMs, env, spawnSyncProcess) && isVoiceboxServiceInstalled(env)
-}
-
-export async function startVoiceboxService(env: NodeJS.ProcessEnv = process.env, spawnSyncProcess: typeof spawnSync = spawnSync): Promise<boolean> {
-  const service = resolveVoiceboxServiceConfig(env)
-  if (!service.autoStart) return false
-  if (!isVoiceboxServiceInstalled(env) && !(await installVoiceboxService(env, spawnSyncProcess))) return false
-  return runShell(service.startCommand, service.startupTimeoutMs, env, spawnSyncProcess)
-}
-
-export async function stopVoiceboxService(env: NodeJS.ProcessEnv = process.env, spawnSyncProcess: typeof spawnSync = spawnSync): Promise<boolean> {
-  const service = resolveVoiceboxServiceConfig(env)
-  if (!service.autoStop) return false
-  if (!isVoiceboxServiceInstalled(env)) return false
-  return runShell(service.stopCommand, service.stopTimeoutMs, env, spawnSyncProcess)
-}
-
-export async function ensureVoiceboxServiceRunning(env: NodeJS.ProcessEnv = process.env, spawnSyncProcess: typeof spawnSync = spawnSync, onStatus?: (message: string, level?: string) => void): Promise<boolean> {
-  const config = resolveVoiceboxConfig(env)
-  if (await checkVoiceboxHealth(config)) return true
-  const service = resolveVoiceboxServiceConfig(env)
-
-  if (!isVoiceboxServiceInstalled(env)) {
-    if (!service.autoInstall) return false
-    onStatus?.(`Voicebox is not installed. Installing to ${service.installDir}…`, "info")
-    if (!(await installVoiceboxService(env, spawnSyncProcess))) return false
-  }
-
-  if (!service.autoStart) return false
-  onStatus?.("Voicebox is not running. Starting local Voicebox container…", "info")
-  const started = await startVoiceboxService(env, spawnSyncProcess)
-  if (!started) return false
-
-  const deadline = Date.now() + service.startupTimeoutMs
-  while (Date.now() < deadline) {
-    if (await checkVoiceboxHealth(config)) return true
-    await sleep(1_000)
-  }
-  return false
-}