dsh-live-voice 0.0.1-developing → 0.1.0

package/src/core/microphone.ts

@@ -0,0 +1,171 @@
+// @ts-nocheck
+/** Local-only audio metering. Audio never leaves this module or reaches speakers.
+ * start({signal}={}) returns true when ready, false on cancellation/replacement.
+ * Permission prompts cannot be dismissed programmatically: late streams are stopped.
+ * stop() invalidates immediately; neither pending permission nor context shutdown blocks it.
+ */
+export class MicrophoneMeter {
+  constructor(globals = globalThis) {
+    this.g = globals;
+    this.epoch = 0;
+    this.current = null;
+    this.stream = this.context = this.source = this.analyser = this.samples = null;
+  }
+
+  async capability() {
+    const secure =
+      this.g.isSecureContext === true ||
+      ['localhost', '127.0.0.1', '::1'].includes(this.g.location?.hostname);
+    if (!secure)
+      return {
+        supported: false,
+        permission: 'unavailable',
+        reason: 'Microphone capture requires a secure or loopback page.',
+      };
+    if (typeof this.g.navigator?.mediaDevices?.getUserMedia !== 'function')
+      return {
+        supported: false,
+        permission: 'unavailable',
+        reason: 'This browser does not expose microphone capture.',
+      };
+    const AudioContext = this.g.AudioContext || this.g.webkitAudioContext;
+    if (typeof AudioContext !== 'function')
+      return {
+        supported: false,
+        permission: 'unavailable',
+        reason: 'This browser does not expose Web Audio for the live waveform.',
+      };
+    let permission = 'prompt';
+    try {
+      const status = await this.g.navigator.permissions?.query?.({ name: 'microphone' });
+      if (['granted', 'denied', 'prompt'].includes(status?.state)) permission = status.state;
+    } catch {
+      /* Permission is discovered only when capture is requested. */
+    }
+    return permission === 'denied'
+      ? {
+          supported: false,
+          permission,
+          reason:
+            'Microphone permission is denied. Allow it in browser settings, then refresh availability.',
+        }
+      : { supported: true, permission };
+  }
+
+  async start({ signal } = {}) {
+    this.stop();
+    if (signal?.aborted) return false;
+    const job = {
+      signal,
+      stream: null,
+      context: null,
+      source: null,
+      analyser: null,
+      samples: null,
+    };
+    const cancelled = new Promise((resolve) => {
+      job.cancelled = resolve;
+    });
+    job.cancel = () => {
+      if (this.current === job) this.stop();
+    };
+    this.current = job;
+    signal?.addEventListener('abort', job.cancel, { once: true });
+    if (signal?.aborted) {
+      job.cancel();
+      return false;
+    }
+    const valid = () => this.current === job;
+    const capture = async () => {
+      try {
+        const stream = await this.g.navigator.mediaDevices.getUserMedia({
+          audio: { echoCancellation: true, noiseSuppression: true, autoGainControl: true },
+        });
+        job.stream = stream;
+        if (!valid()) {
+          this._dispose(job);
+          return false;
+        }
+        this.stream = stream;
+        const AudioContext = this.g.AudioContext || this.g.webkitAudioContext;
+        job.context = new AudioContext();
+        job.analyser = job.context.createAnalyser();
+        job.analyser.fftSize = 256;
+        job.source = job.context.createMediaStreamSource(stream);
+        job.source.connect(job.analyser);
+        job.samples = new Float32Array(job.analyser.fftSize);
+        this.context = job.context;
+        this.source = job.source;
+        this.analyser = job.analyser;
+        this.samples = job.samples;
+        await job.context.resume();
+        return valid();
+      } catch (error) {
+        // A rejected obsolete resume/getUserMedia must never release newer capture.
+        if (!valid()) {
+          this._dispose(job);
+          return false;
+        }
+        this.current = null;
+        this._clear();
+        this._dispose(job);
+        throw error;
+      }
+    };
+    return Promise.race([capture(), cancelled]);
+  }
+
+  level() {
+    if (!this.analyser || !this.samples) return 0;
+    this.analyser.getFloatTimeDomainData(this.samples);
+    return Math.min(
+      1,
+      Math.sqrt(this.samples.reduce((s, x) => s + x * x, 0) / this.samples.length) * 5,
+    );
+  }
+
+  _clear() {
+    this.stream = this.context = this.source = this.analyser = this.samples = null;
+  }
+
+  _dispose(job) {
+    job.signal?.removeEventListener('abort', job.cancel);
+    const stream = job.stream,
+      source = job.source,
+      context = job.context;
+    job.stream = job.source = job.context = job.analyser = job.samples = null;
+    if (stream) {
+      for (const track of stream.getTracks()) {
+        try {
+          track.stop();
+        } catch {
+          /* Continue releasing remaining tracks. */
+        }
+      }
+    }
+    try {
+      source?.disconnect();
+    } catch {
+      /* Already disconnected. */
+    }
+    try {
+      if (context && context.state !== 'closed') Promise.resolve(context.close()).catch(() => {});
+    } catch {
+      /* Closing an obsolete context must not block future capture. */
+    }
+  }
+
+  async release() {
+    return this.stop();
+  }
+
+  async stop() {
+    ++this.epoch;
+    const job = this.current;
+    this.current = null;
+    this._clear();
+    if (!job) return;
+    job.cancelled(false);
+    this._dispose(job);
+  }
+}

package/src/core/ownership.ts

@@ -0,0 +1,31 @@
+// @ts-nocheck
+/** Serialize hardware handoffs without holding the lock for speech duration. */
+export class VoiceOwnership {
+  constructor() {
+    this.epoch = 0;
+    this.tail = Promise.resolve();
+    this.closed = false;
+  }
+  run(owner, owners, action) {
+    const epoch = ++this.epoch;
+    let outcome;
+    const acquired = this.tail.then(async () => {
+      if (this.closed || epoch !== this.epoch || owner.disposed) return;
+      await Promise.all(
+        owners.filter((other) => other !== owner).map((other) => other.endConversation()),
+      );
+      if (this.closed || epoch !== this.epoch || owner.disposed) return;
+      outcome = Promise.resolve(action());
+      outcome.catch(() => {});
+    });
+    this.tail = acquired.catch(() => {});
+    return acquired.then(() => outcome);
+  }
+  cancel() {
+    ++this.epoch;
+  }
+  close() {
+    this.closed = true;
+    this.cancel();
+  }
+}

package/src/core/settings.ts

@@ -0,0 +1,113 @@
+// @ts-nocheck
+export const voiceDetectionPresets = Object.freeze({
+  short: Object.freeze({
+    silenceMs: 900,
+    label: 'Short',
+    description: 'Send quickly after a short pause.',
+  }),
+  natural: Object.freeze({
+    silenceMs: 1500,
+    label: 'Natural',
+    description: 'Allow normal pauses between phrases.',
+  }),
+  long: Object.freeze({
+    silenceMs: 2200,
+    label: 'Long',
+    description: 'Wait through longer thinking pauses.',
+  }),
+});
+export const usesPluginVoiceDetection = (engine) => ['whisper-http', 'qwen-http'].includes(engine);
+export const qwenVoices = Object.freeze([
+  Object.freeze({ value: 'aiden', label: 'Aiden — male, American English' }),
+  Object.freeze({ value: 'ryan', label: 'Ryan — male, English' }),
+  Object.freeze({ value: 'uncle_fu', label: 'Uncle Fu — male, Chinese' }),
+  Object.freeze({ value: 'dylan', label: 'Dylan — male, Beijing Chinese' }),
+  Object.freeze({ value: 'eric', label: 'Eric — male, Sichuan Chinese' }),
+  Object.freeze({ value: 'vivian', label: 'Vivian — female, Chinese' }),
+  Object.freeze({ value: 'serena', label: 'Serena — female, Chinese' }),
+  Object.freeze({ value: 'ono_anna', label: 'Ono Anna — female, Japanese' }),
+  Object.freeze({ value: 'sohee', label: 'Sohee — female, Korean' }),
+]);
+export const defaultQwenVoice = qwenVoices[0].value;
+export const isQwenVoice = (value) => qwenVoices.some((voice) => voice.value === value);
+export const defaultSettings = Object.freeze({
+  engine: 'browser',
+  recognitionEngine: 'browser',
+  recognitionProcessLocally: true,
+  recognitionAutoInstall: true,
+  voiceDetectionPreset: 'natural',
+  announceAssistantMessages: true,
+  interruptSpeechOnUserMessage: false,
+  sendingMode: 'manual',
+  autoSendDelaySeconds: 4,
+  assistantSpeechDelaySeconds: 3,
+  mode: 'speaker',
+  lang: 'pt-BR',
+  recognitionLang: 'pt-BR',
+  voice: '',
+  rate: 1,
+});
+/** Persisted browser preferences are untrusted and may belong to an older version. */
+export function normalizeSettings(value) {
+  const source = value && typeof value === 'object' && !Array.isArray(value) ? value : {};
+  return {
+    engine: ['browser', 'say', 'qwen-http'].includes(source.engine)
+      ? source.engine
+      : defaultSettings.engine,
+    recognitionEngine: ['browser', 'whisper-http', 'qwen-http'].includes(source.recognitionEngine)
+      ? source.recognitionEngine
+      : defaultSettings.recognitionEngine,
+    recognitionProcessLocally:
+      typeof source.recognitionProcessLocally === 'boolean'
+        ? source.recognitionProcessLocally
+        : defaultSettings.recognitionProcessLocally,
+    recognitionAutoInstall:
+      typeof source.recognitionAutoInstall === 'boolean'
+        ? source.recognitionAutoInstall
+        : defaultSettings.recognitionAutoInstall,
+    voiceDetectionPreset: Object.hasOwn(voiceDetectionPresets, source.voiceDetectionPreset)
+      ? source.voiceDetectionPreset
+      : defaultSettings.voiceDetectionPreset,
+    announceAssistantMessages:
+      typeof source.announceAssistantMessages === 'boolean'
+        ? source.announceAssistantMessages
+        : defaultSettings.announceAssistantMessages,
+    interruptSpeechOnUserMessage:
+      typeof source.interruptSpeechOnUserMessage === 'boolean'
+        ? source.interruptSpeechOnUserMessage
+        : defaultSettings.interruptSpeechOnUserMessage,
+    sendingMode: ['manual', 'automatic'].includes(source.sendingMode)
+      ? source.sendingMode
+      : defaultSettings.sendingMode,
+    autoSendDelaySeconds:
+      Number.isInteger(source.autoSendDelaySeconds) &&
+      source.autoSendDelaySeconds >= 2 &&
+      source.autoSendDelaySeconds <= 10
+        ? source.autoSendDelaySeconds
+        : defaultSettings.autoSendDelaySeconds,
+    assistantSpeechDelaySeconds:
+      Number.isInteger(source.assistantSpeechDelaySeconds) &&
+      source.assistantSpeechDelaySeconds >= 1 &&
+      source.assistantSpeechDelaySeconds <= 10
+        ? source.assistantSpeechDelaySeconds
+        : defaultSettings.assistantSpeechDelaySeconds,
+    mode: ['speaker', 'headphones'].includes(source.mode) ? source.mode : defaultSettings.mode,
+    lang:
+      typeof source.lang === 'string' && /^[a-z]{2,3}(?:-[A-Za-z0-9]{2,8})*$/.test(source.lang)
+        ? source.lang
+        : defaultSettings.lang,
+    recognitionLang:
+      source.recognitionLang === 'auto' ||
+      (typeof source.recognitionLang === 'string' &&
+        /^[a-z]{2,3}(?:-[A-Za-z0-9]{2,8})*$/.test(source.recognitionLang))
+        ? source.recognitionLang
+        : typeof source.lang === 'string' && /^[a-z]{2,3}(?:-[A-Za-z0-9]{2,8})*$/.test(source.lang)
+          ? source.lang
+          : defaultSettings.recognitionLang,
+    voice:
+      typeof source.voice === 'string' && source.voice.length <= 200 && !source.voice.includes('\0')
+        ? source.voice
+        : '',
+    rate: Number.isFinite(source.rate) && source.rate >= 0.1 && source.rate <= 3 ? source.rate : 1,
+  };
+}

package/src/core/transcript.ts

@@ -0,0 +1,48 @@
+// @ts-nocheck
+/** Own only the current hypothesis; never restore an old snapshot over user edits. */
+export class TranscriptDraft {
+  constructor() {
+    this.reset();
+  }
+  reset() {
+    this.owned = null;
+    this.edited = false;
+  }
+  update(current, hypothesis, final = false) {
+    if (this.edited) {
+      if (final) this.edited = false;
+      return current;
+    }
+    let base = current;
+    let at = current.length;
+    if (this.owned) {
+      const { start, text, before, after } = this.owned;
+      // Only replace a hypothesis whose surrounding text has not changed.
+      if (current === before + text + after) {
+        base = before + after;
+        at = start;
+      } else if (
+        text &&
+        current.indexOf(text) >= 0 &&
+        current.indexOf(text) === current.lastIndexOf(text)
+      ) {
+        // Edits outside our unchanged, uniquely identifiable hypothesis are safe.
+        at = current.indexOf(text);
+        base = current.slice(0, at) + current.slice(at + text.length);
+      } else {
+        // The user edited the draft: relinquish it. Do not duplicate a final
+        // hypothesis after an edit; the edited text belongs to the user now.
+        this.owned = null;
+        this.edited = !final;
+        return current;
+      }
+    }
+    const before = base.slice(0, at);
+    const after = base.slice(at);
+    const separator = hypothesis && before && !/\s$/.test(before) ? ' ' : '';
+    const text = separator + hypothesis;
+    const result = before + text + after;
+    this.owned = final ? null : { start: at, text, before, after };
+    return result;
+  }
+}

package/src/engines/qwen-http-host.ts

@@ -0,0 +1,240 @@
+// @ts-nocheck
+import { readFile, mkdir, writeFile, rename, rm } from 'node:fs/promises';
+import { homedir } from 'node:os';
+import { dirname, join } from 'node:path';
+import { randomUUID } from 'node:crypto';
+import { defaultQwenVoice, isQwenVoice } from '../core/settings.ts';
+import { validateMonoPcm16Wav } from './recognition/whisper-http-host.ts';
+
+const clean = (value) => String(value ?? '').trim();
+export function resolveQwenBaseUrl(
+  value = process.env.DSH_LIVE_VOICE_QWEN_URL || 'http://127.0.0.1:8080/',
+) {
+  const url = new URL(value);
+  if (!['http:', 'https:'].includes(url.protocol))
+    throw new Error('Qwen API URL must use HTTP or HTTPS.');
+  url.pathname = url.pathname.replace(/\/*$/, '/');
+  url.search = '';
+  url.hash = '';
+  return url;
+}
+export function validateQwenConfig(value) {
+  if (!value || typeof value.baseUrl !== 'string')
+    throw new Error('Qwen API base URL is required.');
+  const baseUrl = resolveQwenBaseUrl(value.baseUrl.trim());
+  if (!Number.isInteger(value.timeoutMs) || value.timeoutMs < 1000 || value.timeoutMs > 600000)
+    throw new Error('Request timeout must be an integer between 1000 and 600000 ms.');
+  return { baseUrl: baseUrl.href, timeoutMs: value.timeoutMs };
+}
+export function createQwenConfigStore(path = join(homedir(), '.dsh', 'dsh-live-voice-qwen.json')) {
+  return {
+    async load() {
+      try {
+        return JSON.parse(await readFile(path, 'utf8'));
+      } catch (error) {
+        if (error.code === 'ENOENT') return null;
+        throw new Error('Cannot read persisted Qwen settings: ' + error.message);
+      }
+    },
+    async save(config) {
+      await mkdir(dirname(path), { recursive: true, mode: 0o700 });
+      const temporary = path + '.' + randomUUID() + '.tmp';
+      try {
+        await writeFile(temporary, JSON.stringify(config, null, 2) + '\n', {
+          mode: 0o600,
+          flag: 'wx',
+        });
+        await rename(temporary, path);
+      } finally {
+        await rm(temporary, { force: true });
+      }
+    },
+  };
+}
+const language = (value) =>
+  value === 'auto'
+    ? undefined
+    : value?.toLowerCase().startsWith('pt')
+      ? 'portuguese'
+      : value?.toLowerCase().startsWith('en')
+        ? 'english'
+        : value;
+export class QwenHttpHost {
+  constructor({
+    baseUrl,
+    timeoutMs = 300000,
+    fetchImpl = globalThis.fetch,
+    maxBytes = 2_000_000,
+    maxSpeechBytes = 50_000_000,
+    store,
+  } = {}) {
+    this.config = validateQwenConfig({ baseUrl: resolveQwenBaseUrl(baseUrl).href, timeoutMs });
+    this.fetch = fetchImpl;
+    this.maxBytes = maxBytes;
+    this.maxSpeechBytes = maxSpeechBytes;
+    this.store = store;
+    this.active = new AbortController();
+    this.queue = Promise.resolve();
+    this.ready = Promise.resolve()
+      .then(async () => {
+        const saved = await store?.load();
+        if (saved) this.config = validateQwenConfig(saved);
+      })
+      .catch((error) => {
+        this.loadError = error;
+      });
+  }
+  async getConfig() {
+    await this.ready;
+    if (this.loadError) throw this.loadError;
+    return { ...this.config };
+  }
+  replaceConfig(value) {
+    const next = validateQwenConfig(value);
+    const operation = this.queue.then(async () => {
+      await this.ready;
+      await this.store?.save(next);
+      this.active.abort();
+      this.active = new AbortController();
+      this.config = next;
+      this.loadError = null;
+      return { ...next };
+    });
+    this.queue = operation.catch(() => {});
+    return operation;
+  }
+  dispose() {
+    this.active.abort();
+  }
+  async request(path, options, configuration, consume = (response) => response) {
+    const config = configuration ? validateQwenConfig(configuration) : await this.getConfig();
+    const timeout = AbortSignal.timeout(config.timeoutMs);
+    const signal = AbortSignal.any([
+      timeout,
+      this.active.signal,
+      ...(options.signal ? [options.signal] : []),
+    ]);
+    const response = await this.fetch(new URL(path, config.baseUrl), {
+      ...options,
+      signal,
+      redirect: 'error',
+    });
+    const value = await consume(response);
+    signal.throwIfAborted();
+    return value;
+  }
+  async serverInfo(signal, configuration) {
+    const response = await this.request('health', { signal }, configuration, async (response) => ({
+      ok: response.ok,
+      status: response.status,
+      body: response.ok ? await response.json() : null,
+    }));
+    return { ...response, ominix: response.body?.service === 'ominix-api' };
+  }
+  async capability(signal, configuration, kind = 'both') {
+    try {
+      const config = configuration ? validateQwenConfig(configuration) : await this.getConfig();
+      const health = await this.serverInfo(signal, config);
+      let models = health.body?.models;
+      if (health.ominix && health.ok) {
+        const status = await this.request(
+          'v1/models/status',
+          { signal },
+          config,
+          async (response) => ({
+            ok: response.ok,
+            status: response.status,
+            body: response.ok ? await response.json() : null,
+          }),
+        );
+        models = {
+          asr: status.body?.models?.asr === 'qwen3-asr',
+          tts: status.body?.models?.qwen3_tts === 'customvoice',
+        };
+      }
+      const ready =
+        kind === 'asr'
+          ? models?.asr === true
+          : kind === 'tts'
+            ? models?.tts === true
+            : models?.asr === true && models?.tts === true;
+      return health.ok && ready
+        ? { supported: true, local: true, location: 'host', streaming: false, models }
+        : {
+            supported: false,
+            local: true,
+            location: 'host',
+            streaming: false,
+            reason: `Qwen health check did not report ${kind === 'both' ? 'both ASR and TTS' : kind.toUpperCase()} ready (${health.status}).`,
+          };
+    } catch (error) {
+      return {
+        supported: false,
+        local: true,
+        location: 'host',
+        streaming: false,
+        reason: 'Qwen speech server is unreachable: ' + (error?.message || error),
+      };
+    }
+  }
+  async transcribe(input, { lang = 'pt-BR', signal } = {}) {
+    const bytes = validateMonoPcm16Wav(input, { maxBytes: this.maxBytes }),
+      resolved = language(lang),
+      health = await this.serverInfo(signal);
+    let body, headers;
+    if (health.ominix) {
+      headers = { 'content-type': 'application/json' };
+      body = JSON.stringify({
+        file: Buffer.from(bytes).toString('base64'),
+        language: resolved,
+        response_format: 'json',
+      });
+    } else {
+      const form = new FormData();
+      form.append('file', new Blob([bytes], { type: 'audio/wav' }), 'utterance.wav');
+      form.append('response_format', 'json');
+      if (resolved) form.append('language', resolved);
+      body = form;
+    }
+    return this.request(
+      'v1/audio/transcriptions',
+      { method: 'POST', headers, body, signal },
+      undefined,
+      async (response) => {
+        if (!response.ok) throw new Error('Qwen transcription failed (' + response.status + ').');
+        const json = await response.json();
+        return { text: clean(json?.text) };
+      },
+    );
+  }
+  async synthesize(text, { lang = 'pt-BR', signal, voice = defaultQwenVoice } = {}) {
+    if (typeof text !== 'string' || !text.trim() || text.length > 100000 || text.includes('\0'))
+      throw new Error('Speech text must contain 1–100000 characters without NUL.');
+    if (!isQwenVoice(voice)) throw new Error('Unsupported Qwen voice.');
+    return this.request(
+      'v1/audio/speech',
+      {
+        method: 'POST',
+        headers: { 'content-type': 'application/json' },
+        body: JSON.stringify({
+          model: 'qwen3-tts',
+          input: text,
+          voice,
+          language: language(lang) || 'portuguese',
+          response_format: 'wav',
+        }),
+        signal,
+      },
+      undefined,
+      async (response) => {
+        if (!response.ok) throw new Error('Qwen synthesis failed (' + response.status + ').');
+        const length = Number(response.headers.get('content-length') || 0);
+        if (length > this.maxSpeechBytes) throw new Error('Qwen speech response is too large.');
+        const bytes = await response.arrayBuffer();
+        if (bytes.byteLength < 44 || bytes.byteLength > this.maxSpeechBytes)
+          throw new Error('Qwen returned invalid or oversized speech audio.');
+        return bytes;
+      },
+    );
+  }
+}