speechflow 1.3.0 → 1.3.2

package/src/speechflow-utils.ts

@@ -24,11 +24,19 @@ export function audioBufferDuration (
     channels     = 1,
     littleEndian = true
 ) {
+    /*  sanity check parameters  */
     if (!Buffer.isBuffer(buffer))
         throw new Error("invalid input (Buffer expected)")
     if (littleEndian !== true)
         throw new Error("only Little Endian supported")
+    if (sampleRate <= 0)
+        throw new Error("sample rate must be positive")
+    if (bitDepth <= 0 || bitDepth % 8 !== 0)
+        throw new Error("bit depth must be positive and multiple of 8")
+    if (channels <= 0)
+        throw new Error("channels must be positive")
 
+    /*  calculate duration  */
     const bytesPerSample = bitDepth / 8
     const totalSamples = buffer.length / (bytesPerSample * channels)
     return totalSamples / sampleRate
@@ -40,12 +48,23 @@ export function audioArrayDuration (
     sampleRate   = 48000,
     channels     = 1
 ) {
+    /*  sanity check parameters  */
+    if (arr.length === 0)
+        return 0
+    if (sampleRate <= 0)
+        throw new Error("sample rate must be positive")
+    if (channels <= 0)
+        throw new Error("channels must be positive")
+
+    /*  calculate duration  */
     const totalSamples = arr.length / channels
     return totalSamples / sampleRate
 }
 
 /*  helper function: convert Buffer in PCM/I16 to Float32Array in PCM/F32 format  */
 export function convertBufToF32 (buf: Buffer, littleEndian = true) {
+    if (buf.length % 2 !== 0)
+        throw new Error("buffer length must be even for 16-bit samples")
     const dataView = new DataView(buf.buffer)
     const arr = new Float32Array(buf.length / 2)
     for (let i = 0; i < arr.length; i++)
@@ -55,9 +74,15 @@ export function convertBufToF32 (buf: Buffer, littleEndian = true) {
 
 /*  helper function: convert Float32Array in PCM/F32 to Buffer in PCM/I16 format  */
 export function convertF32ToBuf (arr: Float32Array) {
+    if (arr.length === 0)
+        return Buffer.alloc(0)
     const int16Array = new Int16Array(arr.length)
-    for (let i = 0; i < arr.length; i++)
-        int16Array[i] = Math.max(-32768, Math.min(32767, Math.round(arr[i] * 32768)))
+    for (let i = 0; i < arr.length; i++) {
+        let sample = arr[i]
+        if (Number.isNaN(sample))
+            sample = 0
+        int16Array[i] = Math.max(-32768, Math.min(32767, Math.round(sample * 32768)))
+    }
     return Buffer.from(int16Array.buffer)
 }
 
@@ -274,26 +299,19 @@ export class QueuePointer<T extends QueueElement> extends EventEmitter {
     }
     position (index?: number): number {
         if (index !== undefined) {
-            this.index = index
-            if (this.index < 0)
-                this.index = 0
-            else if (this.index >= this.queue.elements.length)
-                this.index = this.queue.elements.length
+            this.index = Math.max(0, Math.min(index, this.queue.elements.length))
             this.emit("position", this.index)
         }
         return this.index
     }
     walk (num: number) {
-        if (num > 0) {
-            for (let i = 0; i < num && this.index < this.queue.elements.length; i++)
-                this.index++
+        const indexOld = this.index
+        if (num > 0)
+            this.index = Math.min(this.index + num, this.queue.elements.length)
+        else if (num < 0)
+            this.index = Math.max(this.index + num, 0)
+        if (this.index !== indexOld)
             this.emit("position", { start: this.index })
-        }
-        else if (num < 0) {
-            for (let i = 0; i < Math.abs(num) && this.index > 0; i++)
-                this.index--
-            this.emit("position", { start: this.index })
-        }
     }
     walkForwardUntil (type: T["type"]) {
         while (this.index < this.queue.elements.length
@@ -330,12 +348,7 @@ export class QueuePointer<T extends QueueElement> extends EventEmitter {
     peek (position?: number) {
         if (position === undefined)
             position = this.index
-        else {
-            if (position < 0)
-                position = 0
-            else if (position > this.queue.elements.length)
-                position = this.queue.elements.length
-        }
+        position = Math.max(0, Math.min(position, this.queue.elements.length))
         const element = this.queue.elements[position]
         this.queue.emit("read", { start: position, end: position })
         return element
@@ -351,11 +364,8 @@ export class QueuePointer<T extends QueueElement> extends EventEmitter {
         let slice: T[]
         const start = this.index
         if (size !== undefined) {
-            if (size < 0)
-                size = 0
-            else if (size > this.queue.elements.length - this.index)
-                size = this.queue.elements.length - this.index
-            slice = this.queue.elements.slice(this.index, size)
+            size = Math.max(0, Math.min(size, this.queue.elements.length - this.index))
+            slice = this.queue.elements.slice(this.index, this.index + size)
             this.index += size
         }
         else {
@@ -415,45 +425,58 @@ export class Queue<T extends QueueElement> extends EventEmitter {
                 min = pointer.position()
 
         /*  trim the maximum amount of first elements  */
-        this.elements.splice(0, min)
+        if (min > 0) {
+            this.elements.splice(0, min)
 
-        /*  shift all pointers  */
-        for (const pointer of this.pointers.values())
-            pointer.position(pointer.position() - min)
+            /*  shift all pointers  */
+            for (const pointer of this.pointers.values())
+                pointer.position(pointer.position() - min)
+        }
     }
 }
 
 /*  utility class for wrapping a custom stream into a regular Transform stream  */
 export class StreamWrapper extends Stream.Transform {
     private foreignStream: any
+    private onData  = (chunk: any) => { this.push(chunk) }
+    private onError = (err: Error) => { this.emit("error", err) }
+    private onEnd   = ()           => { this.push(null) }
     constructor (foreignStream: any, options: Stream.TransformOptions = {}) {
         options.readableObjectMode = true
         options.writableObjectMode = true
         super(options)
         this.foreignStream = foreignStream
-        this.foreignStream.on("data", (chunk: any) => {
-            this.push(chunk)
-        })
-        this.foreignStream.on("error", (err: Error) => {
-            this.emit("error", err)
-        })
-        this.foreignStream.on("end", () => {
-            this.push(null)
-        })
+        if (typeof this.foreignStream.on === "function") {
+            this.foreignStream.on("data",  this.onData)
+            this.foreignStream.on("error", this.onError)
+            this.foreignStream.on("end",   this.onEnd)
+        }
     }
     _transform (chunk: any, encoding: BufferEncoding, callback: Stream.TransformCallback): void {
+        if (this.destroyed) {
+            callback(new Error("stream already destroyed"))
+            return
+        }
         try {
-            const canContinue = this.foreignStream.write(chunk)
-            if (canContinue)
-                callback()
+            if (typeof this.foreignStream.write === "function") {
+                const canContinue = this.foreignStream.write(chunk)
+                if (canContinue)
+                    callback()
+                else
+                    this.foreignStream.once("drain", callback)
+            }
             else
-                this.foreignStream.once("drain", callback)
+                throw new Error("foreign stream lacks write method")
         }
         catch (err) {
             callback(err as Error)
         }
     }
     _flush (callback: Stream.TransformCallback): void {
+        if (this.destroyed) {
+            callback(new Error("stream already destroyed"))
+            return
+        }
         try {
             if (typeof this.foreignStream.end === "function")
                 this.foreignStream.end()
@@ -463,6 +486,14 @@ export class StreamWrapper extends Stream.Transform {
             callback(err as Error)
         }
     }
+    _destroy (error: Error | null, callback: Stream.TransformCallback): void {
+        if (typeof this.foreignStream.removeListener === "function") {
+            this.foreignStream.removeListener("data",  this.onData)
+            this.foreignStream.removeListener("error", this.onError)
+            this.foreignStream.removeListener("end",   this.onEnd)
+        }
+        super._destroy(error, callback)
+    }
 }
 
 /*  meta store  */
@@ -485,4 +516,7 @@ export class TimeStore<T> extends EventEmitter {
             if (interval.low < before && interval.high < before)
                 this.tree.remove(interval)
     }
+    clear (): void {
+        this.tree = new IntervalTree.IntervalTree<TimeStoreInterval<T>>()
+    }
 }

package/src/speechflow.ts

@@ -176,6 +176,21 @@ type wsPeerInfo = {
         logPrefix: pkg.name
     })
 
+    /*  catch uncaught exceptions  */
+    process.on("uncaughtException", (err) => {
+        cli!.log("error", `uncaught exception: ${err.message}`)
+        process.exit(1)
+    })
+
+    /*  catch unhandled promise rejections  */
+    process.on("unhandledRejection", (reason) => {
+        if (reason instanceof Error)
+            cli!.log("error", `unhandled rejection: ${reason.message}`)
+        else
+            cli!.log("error", `unhandled rejection: ${reason}`)
+        process.exit(1)
+    })
+
     /*  provide startup information  */
     cli.log("info", `starting SpeechFlow ${pkg["x-stdver"]} (${pkg["x-release"]})`)
 
@@ -185,21 +200,6 @@ type wsPeerInfo = {
         for (const key of Object.keys(result.parsed))
             cli.log("info", `loaded environment variable "${key}" from ".env" files`)
 
-    /*  handle uncaught exceptions  */
-    process.on("uncaughtException", async (err: Error) => {
-        cli!.log("warning", `process crashed with a fatal error: ${err} ${err.stack}`)
-        process.exit(1)
-    })
-
-    /*  handle unhandled promise rejections  */
-    process.on("unhandledRejection", async (reason, promise) => {
-        if (reason instanceof Error)
-            cli!.log("error", `promise rejection not handled: ${reason.message}: ${reason.stack}`)
-        else
-            cli!.log("error", `promise rejection not handled: ${reason}`)
-        process.exit(1)
-    })
-
     /*  sanity check usage  */
     let n = 0
     if (typeof args.e === "string" && args.e !== "") n++
@@ -220,7 +220,16 @@ type wsPeerInfo = {
             throw new Error("invalid configuration file specification (expected \"<id>@<yaml-config-file>\")")
         const [ , id, file ] = m
         const yaml = await cli.input(file, { encoding: "utf8" })
-        const obj: any = jsYAML.load(yaml)
+        let obj: any
+        try {
+            obj = jsYAML.load(yaml)
+        }
+        catch (err) {
+            if (err instanceof Error)
+                throw new Error(`failed to parse YAML configuration: ${err.message}`)
+            else
+                throw new Error(`failed to parse YAML configuration: ${err}`)
+        }
         if (obj[id] === undefined)
             throw new Error(`no such id "${id}" found in configuration file`)
         config = obj[id] as string
@@ -308,7 +317,14 @@ type wsPeerInfo = {
         for (const name of Object.keys(nodes)) {
             cli!.log("info", `gathering status of node <${name}>`)
             const node = new nodes[name](name, cfg, {}, [])
-            const status = await node.status()
+            const status = await Promise.race<{ [ key: string ]: string | number }>([
+                node.status(),
+                new Promise((resolve, reject) => setTimeout(() =>
+                    reject(new Error("timeout")), 10 * 1000))
+            ]).catch((err: Error) => {
+                cli!.log("warning", `[${node.id}]: failed to gather status of node <${node.id}>: ${err.message}`)
+                return {} as { [ key: string ]: string | number }
+            })
             if (Object.keys(status).length > 0) {
                 let first = true
                 for (const key of Object.keys(status)) {
@@ -337,9 +353,9 @@ type wsPeerInfo = {
     }
     catch (err) {
         if (err instanceof Error && err.name === "FlowLinkError")
-            cli!.log("error", `failed to parse SpeechFlow configuration: ${err.toString()}"`)
+            cli!.log("error", `failed to parse SpeechFlow configuration: ${err.toString()}`)
         else if (err instanceof Error)
-            cli!.log("error", `failed to parse SpeechFlow configuration: ${err.message}"`)
+            cli!.log("error", `failed to parse SpeechFlow configuration: ${err.message}`)
         else
             cli!.log("error", "failed to parse SpeechFlow configuration: internal error")
         process.exit(1)
@@ -438,9 +454,13 @@ type wsPeerInfo = {
         /*  open node  */
         cli!.log("info", `open node <${node.id}>`)
         node.setTimeZero(timeZero)
-        await node.open().catch((err: Error) => {
-            cli!.log("error", `[${node.id}]: ${err.message}`)
-            throw new Error(`failed to open node <${node.id}>`)
+        await Promise.race<void>([
+            node.open(),
+            new Promise((resolve, reject) => setTimeout(() =>
+                reject(new Error("timeout")), 10 * 1000))
+        ]).catch((err: Error) => {
+            cli!.log("error", `[${node.id}]: failed to open node <${node.id}>: ${err.message}`)
+            throw new Error(`failed to open node <${node.id}>: ${err.message}`)
         })
     }
 
@@ -462,9 +482,10 @@ type wsPeerInfo = {
         }
     }
 
-    /*  graph processing: PASS 6: track stream finishing  */
+    /*  graph processing: PASS 5: track stream finishing  */
     const activeNodes  = new Set<SpeechFlowNode>()
     const finishEvents = new EventEmitter()
+    finishEvents.setMaxListeners(graphNodes.size + 10)
     for (const node of graphNodes) {
         if (node.stream === null)
             throw new Error(`stream of node <${node.id}> still not initialized`)
@@ -507,12 +528,17 @@ type wsPeerInfo = {
         const name = req.node as string
         const args = req.args as any[]
         const foundNode = Array.from(graphNodes).find((node) => node.id === name)
-        if (foundNode === undefined)
+        if (foundNode === undefined) {
             cli!.log("warning", `external request failed: no such node <${name}>`)
+            throw new Error(`external request failed: no such node <${name}>`)
+        }
         else {
-            await foundNode.receiveRequest(args).catch((err: Error) => {
-                cli!.log("warning", `external request to node <${name}> failed: ${err}`)
-                throw new Error(`external request to node <${name}> failed: ${err}`)
+            await Promise.race<void>([
+                foundNode.receiveRequest(args),
+                new Promise((resolve, reject) => setTimeout(() =>
+                    reject(new Error("timeout")), 10 * 1000))
+            ]).catch((err: Error) => {
+                cli!.log("warning", `external request to node <${name}> failed: ${err.message}`)
             })
         }
     }
@@ -621,7 +647,7 @@ type wsPeerInfo = {
         }
     })
     await hapi.start()
-    cli!.log("info", `HAPI: started REST/WebSocket network service: http://${args.address}:${args.port}`)
+    cli!.log("info", `HAPI: started REST/WebSocket network service: http://${args.a}:${args.p}`)
 
     /*  hook for sendResponse method of nodes  */
     for (const node of graphNodes) {
@@ -629,7 +655,8 @@ type wsPeerInfo = {
             const data = JSON.stringify({ response: "NOTIFY", node: node.id, args })
             for (const [ peer, info ] of wsPeers.entries()) {
                 cli!.log("info", `HAPI: peer ${peer}: ${data}`)
-                info.ws.send(data)
+                if (info.ws.readyState === WebSocket.OPEN)
+                    info.ws.send(data)
             }
         })
     }
@@ -651,9 +678,39 @@ type wsPeerInfo = {
             cli!.log("warning", `**** received signal ${signal} -- shutting down service ****`)
 
         /*  shutdown HAPI service  */
-        cli!.log("info", `HAPI: stopping REST/WebSocket network service: http://${args.address}:${args.port}`)
+        cli!.log("info", `HAPI: stopping REST/WebSocket network service: http://${args.a}:${args.p}`)
         await hapi.stop({ timeout: 2000 })
 
+        /*  clear WebSocket connections  */
+        if (wsPeers.size > 0) {
+            cli!.log("info", "HAPI: closing WebSocket connections")
+            const closePromises: Promise<void>[] = []
+            for (const [ peer, info ] of wsPeers.entries()) {
+                closePromises.push(new Promise<void>((resolve, reject) => {
+                    if (info.ws.readyState !== WebSocket.OPEN)
+                        resolve()
+                    else {
+                        const timeout = setTimeout(() => {
+                            reject(new Error(`timeout for peer ${peer}`))
+                        }, 2 * 1000)
+                        info.ws.once("close", () => {
+                            clearTimeout(timeout)
+                            resolve()
+                        })
+                        info.ws.close()
+                    }
+                }))
+            }
+            await Promise.race([
+                Promise.all(closePromises),
+                new Promise((resolve, reject) =>
+                    setTimeout(() => reject(new Error("timeout for all peers")), 5 * 1000))
+            ]).catch((err) => {
+                cli!.log("warning", `HAPI: WebSockets failed to close: ${err}`)
+            })
+            wsPeers.clear()
+        }
+
         /*  graph processing: PASS 1: disconnect node streams  */
         for (const node of graphNodes) {
             if (node.stream === null) {
@@ -683,8 +740,12 @@ type wsPeerInfo = {
         /*  graph processing: PASS 2: close nodes  */
         for (const node of graphNodes) {
             cli!.log("info", `close node <${node.id}>`)
-            await node.close().catch((err) => {
-                cli!.log("warning", `node <${node.id}> failed to close: ${err}`)
+            await Promise.race<void>([
+                node.close(),
+                new Promise((resolve, reject) => setTimeout(() =>
+                    reject(new Error("timeout")), 10 * 1000))
+            ]).catch((err: Error) => {
+                cli!.log("warning", `node <${node.id}> failed to close: ${err.message}`)
             })
         }
 
@@ -703,6 +764,12 @@ type wsPeerInfo = {
             graphNodes.delete(node)
         }
 
+        /*  clear event emitters  */
+        finishEvents.removeAllListeners()
+
+        /*  clear active nodes  */
+        activeNodes.clear()
+
         /*  terminate process  */
         if (signal === "finished") {
             cli!.log("info", "terminate process (exit code 0)")
@@ -713,24 +780,38 @@ type wsPeerInfo = {
             process.exit(1)
         }
     }
+
+    /*  hook into regular finish  */
     finishEvents.on("finished", () => { shutdown("finished") })
+
+    /*  hook into process signals  */
     process.on("SIGINT",        () => { shutdown("SIGINT")   })
     process.on("SIGUSR1",       () => { shutdown("SIGUSR1")  })
     process.on("SIGUSR2",       () => { shutdown("SIGUSR2")  })
     process.on("SIGTERM",       () => { shutdown("SIGTERM")  })
+
+    /*  re-hook into uncaught exception handler  */
+    process.removeAllListeners("uncaughtException")
     process.on("uncaughtException", (err) => {
-        cli!.log("error", `uncaught exception: ${err}`)
+        cli!.log("error", `uncaught exception: ${err.message}`)
         shutdown("exception")
     })
+
+    /*  re-hook into unhandled promise rejection handler  */
+    process.removeAllListeners("unhandledRejection")
     process.on("unhandledRejection", (reason) => {
-        cli!.log("error", `unhandled rejection: ${reason}`)
+        if (reason instanceof Error)
+            cli!.log("error", `unhandled rejection: ${reason.message}`)
+        else
+            cli!.log("error", `unhandled rejection: ${reason}`)
         shutdown("exception")
     })
 })().catch((err: Error) => {
+    /*  top-level exception handling  */
     if (cli !== null)
-        cli.log("error", err.message)
+        cli.log("error", `${err.message}:\n${err.stack}`)
     else
-        process.stderr.write(`${pkg.name}: ${chalk.red("ERROR")}: ${err.message} ${err.stack}\n`)
+        process.stderr.write(`${pkg.name}: ${chalk.red("ERROR")}: ${err.message}\n${err.stack}\n`)
     process.exit(1)
 })