@pheem49/mint 1.16.0 → 1.17.0

package/src/renderer/shared/speech/player.ts

@@ -0,0 +1,160 @@
+import type { SpeechReply, SpeechTransport } from './types'
+
+type Prepared = Extract<SpeechReply, { kind: 'prepared' }>
+type Input = { chatId: string; turnId?: number; text?: string; automatic?: boolean; audioOnly?: boolean }
+export type SpeechState = 'idle' | 'preparing' | 'speaking'
+
+/** One cancellable playback run, shared by Desktop, Web and Companion. */
+export class SpeechPlayer {
+  private generation = 0
+  private owner: string | null = null
+  private context: AudioContext | null = null
+  private source: AudioBufferSourceNode | null = null
+  private gain: GainNode | null = null
+  private timer: ReturnType<typeof setInterval> | undefined
+  private frame = 0
+  private settle: (() => void) | null = null
+  private renewing = false
+  private localVolume = 1
+  private hostVolume = 1
+  private speaking = false
+  constructor(private transport: SpeechTransport, private changed: (state: SpeechState) => void, private failed: (message: string) => void, private samples?: (samples: Float32Array | null) => void) {}
+
+  unlock(): Promise<void> {
+    try {
+      this.context ??= new AudioContext()
+      const context = this.context
+      return new Promise<void>((resolve, reject) => {
+        const timer = setTimeout(() => reject(new Error('Use the Read button to allow audio playback.')), 1500)
+        context.resume().then(() => { clearTimeout(timer); resolve() }, error => { clearTimeout(timer); reject(error) })
+      })
+    }
+    catch (error) { return Promise.reject(error) }
+  }
+  volume(value: number) {
+    this.localVolume = Math.min(1, Math.max(0, value))
+    if (this.gain) this.gain.gain.value = this.localVolume * this.hostVolume
+  }
+  stop(): Promise<void> {
+    this.generation += 1
+    const owner = this.owner
+    this.owner = null
+    clearInterval(this.timer); this.timer = undefined
+    cancelAnimationFrame(this.frame)
+    const wasSpeaking = this.speaking; this.speaking = false
+    try { this.source?.stop() } catch {}
+    this.source?.disconnect(); this.source = null
+    this.gain?.disconnect(); this.gain = null
+    this.settle?.(); this.settle = null
+    if (wasSpeaking && typeof speechSynthesis !== 'undefined') speechSynthesis.cancel()
+    this.samples?.(null); this.changed('idle')
+    return owner ? this.transport({ operation: 'release', owner }).then(() => {}, () => {}) : Promise.resolve()
+  }
+  async dispose() { const context = this.context; this.context = null; await this.stop(); await context?.close() }
+  private async renew(owner: string): Promise<boolean> {
+    const reply = await this.transport({ operation: 'renew', owner })
+    return reply.kind === 'lease' && reply.active
+  }
+  async play(input: Input): Promise<void> {
+    const previous = this.stop()
+    const generation = this.generation
+    const owner = crypto.randomUUID()
+    this.owner = owner
+    this.changed('preparing')
+    // Resume synchronously from the Read/Enable button's user gesture.
+    const unlocked = this.unlock().then(() => null, error => error)
+    try {
+      await previous; const unlockError = await unlocked; if (unlockError) throw unlockError
+      if (generation !== this.generation) return
+      let prepared: SpeechReply | undefined
+      for (let attempt = 0; attempt < 40; attempt++) {
+        if (generation !== this.generation) return
+        try { prepared = await this.transport({ operation: 'prepare', owner, ...input }); break }
+        catch (error) {
+          if (!input.automatic || !/Another Mint surface/.test(String(error)) || attempt === 39) throw error
+          // Wait for the revoked player to acknowledge stopping; never overlap its final audio segment.
+          await new Promise(resolve => setTimeout(resolve, 300))
+        }
+      }
+      if (generation !== this.generation) return
+      if (!prepared || prepared.kind !== 'prepared') throw new Error('Mint returned no speech plan')
+      this.hostVolume = prepared.volume
+      this.timer = setInterval(() => {
+        if (this.renewing) return
+        this.renewing = true
+        this.renew(owner).then(active => { if (!active && this.owner === owner) void this.stop() })
+          .catch(() => { if (this.owner === owner) void this.stop() }).finally(() => { this.renewing = false })
+      }, 1000)
+      if (prepared.provider === 'native') {
+        if (input.audioOnly) throw new Error('This voice cannot stream audio to Companion')
+        await this.playNative(prepared, generation)
+      } else {
+        for (let index = 0; index < prepared.chunks && generation === this.generation; index++) {
+          const audio = await this.transport({ operation: 'audio', owner, index })
+          if (generation !== this.generation) return
+          if (audio.kind !== 'audio') throw new Error('Mint returned no speech audio')
+          const bytes = Uint8Array.from(atob(audio.data), character => character.charCodeAt(0))
+          const buffer = await this.context!.decodeAudioData(bytes.buffer)
+          if (generation !== this.generation) return
+          await this.playBuffer(buffer, prepared, owner, generation)
+        }
+      }
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error)
+      if (generation === this.generation && !(input.automatic && /already been read automatically|Another Mint surface|A newer message|Automatic replies are routed/.test(message))) this.failed(message)
+    } finally {
+      if (generation === this.generation) await this.stop()
+      // Covers cancellation racing with preparation on another socket/process.
+      else await this.transport({ operation: 'release', owner }).catch(() => {})
+    }
+  }
+  private async playBuffer(buffer: AudioBuffer, plan: Prepared, owner: string, generation: number) {
+    const context = this.context!
+    const gain = context.createGain(); this.gain = gain
+    gain.gain.value = plan.volume * this.localVolume
+    const analyser = context.createAnalyser(); analyser.fftSize = 256
+    gain.connect(analyser); analyser.connect(context.destination)
+    const samples = new Float32Array(analyser.fftSize)
+    let frame = 0
+    const sample = () => {
+      if (generation !== this.generation) return
+      analyser.getFloatTimeDomainData(samples); this.samples?.(samples)
+      frame = requestAnimationFrame(sample); this.frame = frame
+    }
+    this.changed('speaking'); this.speaking = true; sample()
+    try {
+      // Short independently leased segments cannot continue for minutes after a frozen tab loses ownership.
+      let offset = 0
+      while (offset < buffer.duration && generation === this.generation) {
+        if (!await this.renew(owner) || generation !== this.generation) return
+        const length = Math.min(4 * plan.speed, buffer.duration - offset)
+        await new Promise<void>(resolve => {
+          const source = context.createBufferSource(); this.source = source
+          source.buffer = buffer; source.playbackRate.value = plan.speed
+          source.connect(gain); this.settle = resolve
+          source.onended = () => { source.disconnect(); if (this.source === source) { this.source = null; this.settle = null } resolve() }
+          source.start(0, offset, length)
+        })
+        offset += length
+      }
+    } finally {
+      cancelAnimationFrame(frame); if (generation === this.generation) this.samples?.(null)
+      analyser.disconnect(); gain.disconnect(); if (this.gain === gain) this.gain = null
+    }
+  }
+  private async playNative(plan: Prepared, generation: number) {
+    if (typeof speechSynthesis === 'undefined') throw new Error('System speech is unavailable')
+    this.changed('speaking'); this.speaking = true
+    await new Promise<void>((resolve, reject) => {
+      const utterance = new SpeechSynthesisUtterance(plan.text)
+      utterance.lang = /[\u0e00-\u0e7f]/.test(plan.text) ? 'th-TH' : 'en-US'
+      utterance.volume = plan.volume * this.localVolume; utterance.rate = plan.speed; utterance.pitch = plan.pitch
+      const voice = speechSynthesis.getVoices().find(voice => voice.lang.toLowerCase().startsWith(utterance.lang.slice(0, 2)))
+      if (voice) utterance.voice = voice
+      this.settle = resolve
+      utterance.onend = () => { if (this.settle === resolve) this.settle = null; resolve() }
+      utterance.onerror = event => { if (this.settle === resolve) this.settle = null; if (generation !== this.generation) resolve(); else reject(new Error(event.error)) }
+      speechSynthesis.speak(utterance)
+    })
+  }
+}

package/src/renderer/shared/speech/types.ts

@@ -0,0 +1,11 @@
+export type SpeechRequest =
+  | { operation: 'prefer'; owner: string; chatId: string; enabled: boolean }
+  | { operation: 'prepare'; owner: string; chatId: string; turnId?: number; text?: string; automatic?: boolean; audioOnly?: boolean; routeOwner?: string }
+  | { operation: 'audio'; owner: string; index: number }
+  | { operation: 'renew' | 'release'; owner: string }
+export type SpeechReply =
+  | { kind: 'prepared'; text: string; provider: string; volume: number; speed: number; pitch: number; chunks: number }
+  | { kind: 'audio'; data: string }
+  | { kind: 'lease'; active: boolean }
+  | { kind: 'released' }
+export type SpeechTransport = (request: SpeechRequest) => Promise<SpeechReply>

package/src/renderer/shared/theme/themeManager.test.ts

@@ -40,4 +40,24 @@ describe('theme surface settings', () => {
     expect(attributes.get('data-surface')).toBe('opaque')
     expect(properties.get('--glass-blur')).toBe('none')
   })
+
+  it('sets data-accent-mode to monochrome for pure white accent', () => {
+    applyTheme({ theme: 'dark', accentColor: '#ffffff' })
+    expect(attributes.get('data-accent-mode')).toBe('monochrome')
+  })
+
+  it('sets data-accent-mode to gray for neutral gray accents', () => {
+    applyTheme({ theme: 'dark', accentColor: '#52525b' })
+    expect(attributes.get('data-accent-mode')).toBe('gray')
+  })
+
+  it('sets data-accent-mode to color for standard color accents', () => {
+    applyTheme({ theme: 'dark', accentColor: '#10b981' })
+    expect(attributes.get('data-accent-mode')).toBe('color')
+  })
+
+  it('correctly sets data-theme to studio when studio theme is selected', () => {
+    applyTheme({ theme: 'studio' })
+    expect(attributes.get('data-theme')).toBe('studio')
+  })
 })

package/src/renderer/shared/theme/themeManager.ts

@@ -83,9 +83,11 @@ export const applyTheme = (cfg: any): void => {
   document.documentElement.setAttribute('data-theme', effectiveTheme)
   document.documentElement.setAttribute('data-surface', surfaceStyle)
   const normalizedAccent = accentColor.trim().toLowerCase()
+  const isMonochrome = normalizedAccent === '#ffffff' || normalizedAccent === '#fff'
+  const isGray = normalizedAccent === '#52525b' || normalizedAccent === '#475569' || normalizedAccent === '#3f3f46' || normalizedAccent === '#64748b'
   document.documentElement.setAttribute(
     'data-accent-mode',
-    normalizedAccent === '#ffffff' || normalizedAccent === '#fff' ? 'monochrome' : 'color'
+    isMonochrome ? 'monochrome' : (isGray ? 'gray' : 'color')
   )
 
   // Set Accent variables

package/src/renderer/shared/theme/themes.ts

@@ -3,7 +3,7 @@
  * TypeScript constants and types for the Mint GUI Theme System.
  */
 
-export type ColorMode = 'system' | 'dark' | 'light' | 'midnight'
+export type ColorMode = 'system' | 'dark' | 'light' | 'midnight' | 'studio'
 export type SurfaceStyle = 'opaque' | 'glass'
 
 export interface AccentFlavor {
@@ -63,7 +63,7 @@ export interface ThemePreset {
   id: string
   name: string
   description: string
-  theme: 'dark' | 'light' | 'midnight'
+  theme: 'dark' | 'light' | 'midnight' | 'studio'
   accentColor: string
   systemTextColor: string
   chatTextColor: string
@@ -77,7 +77,7 @@ export const THEME_PRESETS: ThemePreset[] = [
   {
     id: 'preset-dark-mint',
     name: 'Dark Mint',
-    description: 'Black background · Green elements · White text',
+    description: 'Black background · Mint green & slate gray elements',
     theme: 'dark',
     accentColor: '#10b981',
     systemTextColor: '#f8fafc',
@@ -100,10 +100,23 @@ export const THEME_PRESETS: ThemePreset[] = [
     accentPreview: '#10b981',
     textPreview: '#0f172a',
   },
+  {
+    id: 'preset-studio-dark',
+    name: 'Studio Dark',
+    description: '#101010 canvas · #1c1c1c surfaces · #323232 active',
+    theme: 'studio',
+    accentColor: '#10b981',
+    systemTextColor: '#e1e1e1',
+    chatTextColor: '#e1e1e1',
+    bgPreview: '#101010',
+    panelPreview: '#161616',
+    accentPreview: '#10b981',
+    textPreview: '#e1e1e1',
+  },
   {
     id: 'preset-dark-mono',
     name: 'Dark Monochrome',
-    description: 'Black background · White elements · White text',
+    description: 'Black background · Slate gray surfaces · White text',
     theme: 'dark',
     accentColor: '#ffffff',
     systemTextColor: '#f8fafc',