@goodandready/dsh-voice 0.9.38 → 0.9.40

package/lib/host-routes.js

@@ -4,6 +4,7 @@ import { readBody, isLoopback, isTrustedCaller, getVoiceSessionToken } from './h
 import { resolveSensevoiceProvider } from './sensevoice-installer.js'
 import { applyVoiceMacros } from './macros.js'
 import { createSyntheticWav } from './wav.js'
+import { handleWsUpgrade } from './ws-framer.js'
 
 function writeJson(res, status, obj) {
   res.writeHead(status, { 'content-type': 'application/json' })
@@ -361,4 +362,96 @@ export function registerHostRoutes(ctx, deps) {
       }
     },
   }), 'dsh-voice: /transcribe route')
+
+  ctx.effect(() => ctx.webServer.register({
+    kind: 'exact',
+    path: '/dsh-voice/vad/status',
+    handler: async (req, res) => {
+      if (!isTrustedCaller(req)) { writeJson(res, 403, { ok: false, error: 'forbidden' }); return }
+      writeJson(res, 200, { ok: true, sileroAvailable: true, sampleRate: 16000, frameSamples: 512 })
+    },
+  }), 'dsh-voice: /dsh-voice/vad/status route')
+
+  if (typeof ctx.webServer.registerUpgrade === 'function') {
+    ctx.effect(() => {
+      const unreg = ctx.webServer.registerUpgrade({
+        path: '/dsh-voice/ws/stream',
+        handler: (req, socket, head) => {
+          if (!isTrustedCaller(req)) {
+            socket.write('HTTP/1.1 403 Forbidden\r\n\r\n')
+            socket.destroy()
+            return
+          }
+          const url = new URL(req.url || '/', 'http://127.0.0.1')
+          const token = req.headers['x-dsh-voice-token'] || url.searchParams.get('token')
+          const expected = getVoiceSessionToken()
+          if (expected && token !== expected) {
+            socket.write('HTTP/1.1 401 Unauthorized\r\n\r\n')
+            socket.destroy()
+            return
+          }
+
+          handleWsUpgrade(req, socket, head, (ws) => {
+            let streamChunks = []
+            let streamMime = 'audio/webm'
+            let streamMode = 'dictation'
+            ws.on('message', async (data, isBinary) => {
+              if (isBinary && Buffer.isBuffer(data)) {
+                streamChunks.push(data)
+              } else if (typeof data === 'string') {
+                try {
+                  const msg = JSON.parse(data)
+                  if (msg.type === 'init') {
+                    streamMime = msg.mimeType || 'audio/webm'
+                    streamMode = msg.mode || 'dictation'
+                    ws.send(JSON.stringify({ type: 'ready' }))
+                  } else if (msg.type === 'chunk' && msg.dataBase64) {
+                    streamChunks.push(Buffer.from(msg.dataBase64, 'base64'))
+                  } else if (msg.type === 'interim') {
+                    if (streamChunks.length > 0) {
+                      const buf = Buffer.concat(streamChunks)
+                      if (buf.length > 3000) {
+                        try {
+                          const interimOut = await transcribe(buf, streamMime, streamMode)
+                          if (interimOut && interimOut.text) {
+                            ws.send(JSON.stringify({ type: 'interim', text: interimOut.text }))
+                          }
+                        } catch (_) {}
+                      }
+                    }
+                  } else if (msg.type === 'finish') {
+                    const buf = Buffer.concat(streamChunks)
+                    streamChunks = []
+                    if (buf.length < 600) {
+                      ws.send(JSON.stringify({ type: 'final', text: '', ok: true }))
+                      return
+                    }
+                    try {
+                      const finalOut = await transcribe(buf, streamMime, streamMode)
+                      let text = finalOut && finalOut.text ? finalOut.text : ''
+                      let action = null
+                      if (extractVoiceActions) {
+                        const act = extractVoiceActions(text)
+                        if (act.action) { action = act.action; text = act.text }
+                      }
+                      ws.send(JSON.stringify({
+                        type: 'final', text, action,
+                        provider: finalOut.provider || 'unknown', ok: true,
+                      }))
+                    } catch (err) {
+                      ws.send(JSON.stringify({
+                        type: 'error',
+                        error: String(err && err.message ? err.message : err), ok: false,
+                      }))
+                    }
+                  }
+                } catch (_) {}
+              }
+            })
+          })
+        },
+      })
+      return () => { if (typeof unreg === 'function') unreg() }
+    }, 'dsh-voice: /dsh-voice/ws/stream upgrade route')
+  }
 }

package/lib/index.js

@@ -93,11 +93,16 @@ export function apply(ctx, baseConfig) {
     }
   }
 
+  /**
+   * Resolve one environment reference to its secret.
+   * `ref` is a plain string (e.g. `DEEPGRAM_API_KEY`); `credentials.resolve()`
+   * answers `{ value, source }`, so the value is unwrapped here.
+   */
   const resolveKey = async (ref) => {
-    if (!ref || !ref.type) return ''
+    if (!ref || typeof ref !== 'string') return ''
     try {
       const resolved = await ctx.credentials.resolve(credentialRef(ref))
-      return resolved || ''
+      return (typeof resolved === 'string' ? resolved : resolved?.value) || ''
     } catch {
       return ''
     }

package/lib/schema.js

@@ -106,6 +106,10 @@ export const BaseConfig = z.object({
     .description('Microphone device id for recording. Empty means the system default.'),
   noiseGateDb: z.number().default(-45)
     .description('Audio noise gate threshold in dB for client-side recording (-50 to -25 dB, or <= -90 to disable). Silence below this threshold cuts ambient background noise and prevents false VAD triggers.'),
+  vadEngine: z.union(['silero', 'amplitude']).default('silero')
+    .description('Voice activity detection engine: neural Silero VAD (WASM/ONNX) or classic amplitude threshold.'),
+  streamingWs: z.boolean().default(true)
+    .description('Enable ultra-low latency WebSocket streaming to local SenseVoice/Whisper servers with seamless HTTP fallback.'),
   historyLimit: z.number().default(20)
     .description('How many recent dictation inserts to keep for undo in the browser. 0 disables history.'),
   vocabulary: z.array(z.string()).default([])

package/lib/ws-framer.js

@@ -0,0 +1,160 @@
+// Pure Node.js RFC 6455 WebSocket framer & upgrade handler with zero dependencies.
+import crypto from 'node:crypto'
+import { EventEmitter } from 'node:events'
+
+const WS_GUID = '258EAFA5-E914-47DA-95CA-C5AB0DC85B11'
+
+export function computeAcceptKey(key) {
+  return crypto.createHash('sha1').update(String(key || '') + WS_GUID).digest('base64')
+}
+
+export function createWsFrame(data, opcode = 0x01) {
+  const isBinary = Buffer.isBuffer(data)
+  const payload = isBinary ? data : Buffer.from(String(data || ''), 'utf8')
+  const op = isBinary ? 0x02 : opcode
+  const len = payload.length
+
+  let header
+  if (len <= 125) {
+    header = Buffer.alloc(2)
+    header[0] = 0x80 | (op & 0x0f)
+    header[1] = len
+  } else if (len <= 65535) {
+    header = Buffer.alloc(4)
+    header[0] = 0x80 | (op & 0x0f)
+    header[1] = 126
+    header.writeUInt16BE(len, 2)
+  } else {
+    header = Buffer.alloc(10)
+    header[0] = 0x80 | (op & 0x0f)
+    header[1] = 127
+    header.writeBigUInt64BE(BigInt(len), 2)
+  }
+  return Buffer.concat([header, payload])
+}
+
+export class WsConnection extends EventEmitter {
+  constructor(socket) {
+    super()
+    this.socket = socket
+    this.readyState = 1 // OPEN
+    this._buffer = Buffer.alloc(0)
+
+    socket.on('data', (chunk) => this._onData(chunk))
+    socket.on('close', () => {
+      this.readyState = 3
+      this.emit('close')
+    })
+    socket.on('error', (err) => {
+      this.emit('error', err)
+    })
+  }
+
+  send(data) {
+    if (this.readyState !== 1 || !this.socket.writable) return false
+    try {
+      this.socket.write(createWsFrame(data))
+      return true
+    } catch (e) {
+      this.emit('error', e)
+      return false
+    }
+  }
+
+  close(code = 1000, reason = '') {
+    if (this.readyState !== 1) return
+    this.readyState = 2 // CLOSING
+    try {
+      const reasonBuf = Buffer.from(reason, 'utf8')
+      const payload = Buffer.alloc(2 + reasonBuf.length)
+      payload.writeUInt16BE(code, 0)
+      reasonBuf.copy(payload, 2)
+      this.socket.write(createWsFrame(payload, 0x08))
+      this.socket.end()
+    } catch (_) {
+      try { this.socket.destroy() } catch (_) {}
+    }
+    this.readyState = 3
+  }
+
+  _onData(chunk) {
+    this._buffer = Buffer.concat([this._buffer, chunk])
+    while (this._buffer.length >= 2) {
+      const b0 = this._buffer[0]
+      const b1 = this._buffer[1]
+      const opcode = b0 & 0x0f
+      const isMasked = (b1 & 0x80) !== 0
+      let payloadLen = b1 & 0x7f
+      let offset = 2
+
+      if (payloadLen === 126) {
+        if (this._buffer.length < offset + 2) break
+        payloadLen = this._buffer.readUInt16BE(offset)
+        offset += 2
+      } else if (payloadLen === 127) {
+        if (this._buffer.length < offset + 8) break
+        payloadLen = Number(this._buffer.readBigUInt64BE(offset))
+        offset += 8
+      }
+
+      let maskKey = null
+      if (isMasked) {
+        if (this._buffer.length < offset + 4) break
+        maskKey = this._buffer.slice(offset, offset + 4)
+        offset += 4
+      }
+
+      if (this._buffer.length < offset + payloadLen) break
+      const rawPayload = this._buffer.slice(offset, offset + payloadLen)
+      this._buffer = this._buffer.slice(offset + payloadLen)
+
+      let payload = rawPayload
+      if (maskKey) {
+        payload = Buffer.alloc(rawPayload.length)
+        for (let i = 0; i < rawPayload.length; i++) {
+          payload[i] = rawPayload[i] ^ maskKey[i % 4]
+        }
+      }
+
+      if (opcode === 0x08) { // CLOSE
+        this.close()
+        break
+      } else if (opcode === 0x09) { // PING -> PONG
+        if (this.readyState === 1 && this.socket.writable) {
+          try { this.socket.write(createWsFrame(payload, 0x0a)) } catch (_) {}
+        }
+      } else if (opcode === 0x01) { // TEXT
+        this.emit('message', payload.toString('utf8'), false)
+      } else if (opcode === 0x02) { // BINARY
+        this.emit('message', payload, true)
+      }
+    }
+  }
+}
+
+export function handleWsUpgrade(req, socket, head, callback) {
+  const key = req.headers['sec-websocket-key']
+  if (!key) {
+    socket.write('HTTP/1.1 400 Bad Request\r\n\r\n')
+    socket.destroy()
+    return null
+  }
+  const accept = computeAcceptKey(key)
+  const responseHeaders = [
+    'HTTP/1.1 101 Switching Protocols',
+    'Upgrade: websocket',
+    'Connection: Upgrade',
+    `Sec-WebSocket-Accept: ${accept}`,
+    '\r\n',
+  ].join('\r\n')
+
+  socket.write(responseHeaders)
+  const ws = new WsConnection(socket)
+  if (head && head.length > 0) {
+    ws._onData(head)
+  }
+  if (typeof callback === 'function') {
+    callback(ws)
+  }
+  return ws
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@goodandready/dsh-voice",
-  "version": "0.9.38",
+  "version": "0.9.40",
   "description": "Voice input for DeepSeek Harness: dictation chunked by pauses and voice messages, each with its own provider fallback chain (Deepgram, Groq, HuggingFace, local whisper.cpp, plus any OpenAI-compatible API of your own).",
   "license": "MIT",
   "type": "module",