speechflow 1.4.4 → 1.5.0

package/speechflow-cli/src/speechflow.ts

@@ -15,6 +15,7 @@ import Inert             from "@hapi/inert"
 import WebSocket         from "ws"
 import HAPIWebSocket     from "hapi-plugin-websocket"
 import HAPIHeader        from "hapi-plugin-header"
+import OSC               from "osc-js"
 
 /*  external dependencies  */
 import { DateTime }      from "luxon"
@@ -48,6 +49,7 @@ type wsPeerInfo = {
 }
 
 /*  establish asynchronous environment  */
+let debug = false
 ;(async () => {
     /*  determine system paths  */
     const { dataDir } = syspath({
@@ -69,6 +71,7 @@ type wsPeerInfo = {
             "[-p|--port <tcp-port>] " +
             "[-C|--cache <directory>] " +
             "[-d|--dashboard <type>:<id>:<name>[,...]] " +
+            "[-o|--osc <ip-address>:<udp-port> " +
             "[-e|--expression <expression>] " +
             "[-f|--file <file>] " +
             "[-c|--config <id>@<yaml-config-file>] " +
@@ -136,6 +139,15 @@ type wsPeerInfo = {
             default:  "",
             describe: "list of dashboard block types and names"
         })
+        .option("o", {
+            alias:    "osc",
+            type:     "string",
+            array:    false,
+            coerce,
+            nargs:    1,
+            default:  "",
+            describe: "OSC/UDP endpoint to send dashboard information"
+        })
         .option("e", {
             alias:    "expression",
             type:     "string",
@@ -186,17 +198,26 @@ type wsPeerInfo = {
         logTime:   true,
         logPrefix: pkg.name
     })
+    if (args.v.match(/^(?:info|debug)$/))
+        debug = true
 
     /*  catch uncaught exceptions  */
     process.on("uncaughtException", (err) => {
-        cli!.log("error", `uncaught exception: ${err.message}\n${err.stack}`)
+        if (debug)
+            cli!.log("error", `uncaught exception: ${err.message}\n${err.stack}`)
+        else
+            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}\n${reason.stack}`)
+        if (reason instanceof Error) {
+            if (debug)
+                cli!.log("error", `unhandled rejection: ${reason.message}\n${reason.stack}`)
+            else
+                cli!.log("error", `unhandled rejection: ${reason.message}`)
+        }
         else
             cli!.log("error", `unhandled rejection: ${reason}`)
         process.exit(1)
@@ -206,7 +227,11 @@ type wsPeerInfo = {
     cli.log("info", `starting SpeechFlow ${pkg["x-stdver"]} (${pkg["x-release"]})`)
 
     /*  load .env files  */
-    const result = dotenvx.config({ encoding: "utf8", quiet: true })
+    const result = dotenvx.config({
+        encoding: "utf8",
+        ignore:   [ "MISSING_ENV_FILE" ],
+        quiet:    true
+    })
     if (result?.parsed !== undefined)
         for (const key of Object.keys(result.parsed))
             cli.log("info", `loaded environment variable "${key}" from ".env" files`)
@@ -216,8 +241,10 @@ type wsPeerInfo = {
     if (typeof args.e === "string" && args.e !== "") n++
     if (typeof args.f === "string" && args.f !== "") n++
     if (typeof args.c === "string" && args.c !== "") n++
-    if (n !== 1)
-        throw new Error("cannot use more than one FlowLink specification source (either option -e, -f or -c)")
+    if (n === 0)
+        throw new Error("need at least one FlowLink specification source (use one of the options -e, -f or -c)")
+    else if (n !== 1)
+        throw new Error("cannot use more than one FlowLink specification source (use only one of the options -e, -f or -c)")
 
     /*  read configuration  */
     let config = ""
@@ -251,15 +278,25 @@ type wsPeerInfo = {
 
     /*  load internal SpeechFlow nodes  */
     const pkgsI = [
+        "./speechflow-node-a2a-compressor.js",
+        "./speechflow-node-a2a-expander.js",
         "./speechflow-node-a2a-ffmpeg.js",
+        "./speechflow-node-a2a-filler.js",
+        "./speechflow-node-a2a-gain.js",
         "./speechflow-node-a2a-gender.js",
         "./speechflow-node-a2a-meter.js",
         "./speechflow-node-a2a-mute.js",
+        "./speechflow-node-a2a-rnnoise.js",
+        "./speechflow-node-a2a-speex.js",
         "./speechflow-node-a2a-vad.js",
         "./speechflow-node-a2a-wav.js",
+        "./speechflow-node-a2t-awstranscribe.js",
         "./speechflow-node-a2t-deepgram.js",
+        "./speechflow-node-a2t-openaitranscribe.js",
+        "./speechflow-node-t2a-awspolly.js",
         "./speechflow-node-t2a-elevenlabs.js",
         "./speechflow-node-t2a-kokoro.js",
+        "./speechflow-node-t2t-awstranslate.js",
         "./speechflow-node-t2t-deepl.js",
         "./speechflow-node-t2t-format.js",
         "./speechflow-node-t2t-ollama.js",
@@ -313,6 +350,19 @@ type wsPeerInfo = {
         cacheDir:          args.C
     }
 
+    /*  provide access to internal communication busses  */
+    const busses = new Map<string, EventEmitter>()
+    const accessBus = (name: string): EventEmitter => {
+        let bus: EventEmitter
+        if (busses.has(name))
+            bus = busses.get(name)!
+        else {
+            bus = new EventEmitter()
+            busses.set(name, bus)
+        }
+        return bus
+    }
+
     /*  handle one-time status query of nodes  */
     if (args.S) {
         const table = new Table({
@@ -328,6 +378,7 @@ type wsPeerInfo = {
         for (const name of Object.keys(nodes)) {
             cli!.log("info", `gathering status of node <${name}>`)
             const node = new nodes[name](name, cfg, {}, [])
+            node._accessBus = accessBus
             const status = await Promise.race<{ [ key: string ]: string | number }>([
                 node.status(),
                 new Promise<never>((resolve, reject) => setTimeout(() =>
@@ -387,6 +438,7 @@ type wsPeerInfo = {
                     nodeNums.set(NodeClass, ++num)
                     const name = num === 1 ? id : `${id}:${num}`
                     node = new NodeClass(name, cfg, opts, args)
+                    node._accessBus = accessBus
                 }
                 catch (err) {
                     /*  fatal error  */
@@ -402,7 +454,7 @@ type wsPeerInfo = {
                 graphNodes.add(node)
                 return node
             },
-            connectNode (node1: SpeechFlowNode, node2: SpeechFlowNode) {
+            connectNodes (node1: SpeechFlowNode, node2: SpeechFlowNode) {
                 cli!.log("info", `connect node <${node1.id}> to node <${node2.id}>`)
                 node1.connect(node2)
             }
@@ -465,7 +517,7 @@ type wsPeerInfo = {
             new Promise<never>((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}`)
+            cli!.log("error", `<${node.id}>: failed to open node <${node.id}>: ${err.message}`)
             throw new Error(`failed to open node <${node.id}>: ${err.message}`)
         })
     }
@@ -615,8 +667,7 @@ type wsPeerInfo = {
     hapi.route({
         method: "GET",
         path:   "/api/{req}/{node}/{params*}",
-        options: {
-        },
+        options: {},
         handler: (request: HAPI.Request, h: HAPI.ResponseToolkit) => {
             const peer = request.info.remoteAddress
             const params = request.params.params as string ?? ""
@@ -628,11 +679,9 @@ type wsPeerInfo = {
                 args:    params.split("/").filter((seg) => seg !== "")
             }
             cli!.log("info", `HAPI: peer ${peer}: GET: ${JSON.stringify(req)}`)
-            return consumeExternalRequest(req).then(() => {
-                return h.response({ response: "OK" }).code(200)
-            }).catch((err) => {
-                return h.response({ response: "ERROR", data: err.message }).code(417)
-            })
+            return consumeExternalRequest(req)
+                .then(()     => h.response({ response: "OK" }).code(200))
+                .catch((err) => h.response({ response: "ERROR", data: err.message }).code(417))
         }
     })
     hapi.route({
@@ -675,11 +724,9 @@ type wsPeerInfo = {
             if (req instanceof arktype.type.errors)
                 return h.response({ response: "ERROR", data: `invalid request: ${req.summary}` }).code(417)
             cli!.log("info", `HAPI: peer ${peer}: POST: ${JSON.stringify(req)}`)
-            return consumeExternalRequest(req).then(() => {
-                return h.response({ response: "OK" }).code(200)
-            }).catch((err: Error) => {
-                return h.response({ response: "ERROR", data: err.message }).code(417)
-            })
+            return consumeExternalRequest(req)
+                .then(()            => h.response({ response: "OK" }).code(200))
+                .catch((err: Error) => h.response({ response: "ERROR", data: err.message }).code(417))
         }
     })
     await hapi.start()
@@ -697,10 +744,25 @@ type wsPeerInfo = {
         })
     }
 
-    /*  hook for dashboardInfo method of nodes  */
+    /*  establish OSC event emission  */
+    let sendOSC: (url: string, ...args: any[]) => void
+    if (args.o !== "") {
+        const osc = new OSC({ plugin: new OSC.DatagramPlugin({ type: "udp4" }) })
+        const m = args.o.match(/^(.+?):(\d+)$/)
+        if (m === null)
+            throw new Error("invalid OSC/UDP endpoint (expected <ip-adress>:<udp-port>)")
+        const host = m[1]
+        const port = m[2]
+        sendOSC = (url: string, ...args: any[]) => {
+            const msg = new OSC.Message(url, ...args)
+            osc.send(msg, { host, port })
+        }
+    }
+
+    /*  hook for send-dashboard method of nodes  */
     for (const node of graphNodes) {
-        node.on("dashboard-info", (info: {
-            type: string,
+        node.on("send-dashboard", (info: {
+            type: "audio" | "text",
             id:   string,
             kind: "final" | "intermediate",
             value: string | number
@@ -714,6 +776,17 @@ type wsPeerInfo = {
                 cli!.log("debug", `HAPI: dashboard peer ${peer}: send ${data}`)
                 info.ws.send(data)
             }
+            for (const node of graphNodes) {
+                Promise.race<void>([
+                    node.receiveDashboard(info.type, info.id, info.kind, info.value),
+                    new Promise<never>((resolve, reject) => setTimeout(() =>
+                        reject(new Error("timeout")), 10 * 1000))
+                ]).catch((err: Error) => {
+                    cli!.log("warning", `sending dashboard info to node <${node.id}> failed: ${err.message}`)
+                })
+            }
+            if (args.o !== "")
+                sendOSC("/speechflow/dashboard", info.type, info.id, info.kind, info.value)
         })
     }
 
@@ -849,25 +922,40 @@ type wsPeerInfo = {
     /*  re-hook into uncaught exception handler  */
     process.removeAllListeners("uncaughtException")
     process.on("uncaughtException", (err) => {
-        cli!.log("error", `uncaught exception: ${err.message}\n${err.stack}`)
+        if (debug)
+            cli!.log("error", `uncaught exception: ${err.message}\n${err.stack}`)
+        else
+            cli!.log("error", `uncaught exception: ${err.message}`)
         shutdown("exception")
     })
 
     /*  re-hook into unhandled promise rejection handler  */
     process.removeAllListeners("unhandledRejection")
     process.on("unhandledRejection", (reason) => {
-        if (reason instanceof Error)
-            cli!.log("error", `unhandled rejection: ${reason.message}\n${reason.stack}`)
+        if (reason instanceof Error) {
+            if (debug)
+                cli!.log("error", `unhandled rejection: ${reason.message}\n${reason.stack}`)
+            else
+                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}:\n${err.stack}`)
-    else
-        process.stderr.write(`${pkg.name}: ${chalk.red("ERROR")}: ${err.message}\n${err.stack}\n`)
+    if (cli !== null) {
+        if (debug)
+            cli.log("error", `${err.message}\n${err.stack}`)
+        else
+            cli.log("error", `${err.message}`)
+    }
+    else {
+        if (debug)
+            process.stderr.write(`${pkg.name}: ${chalk.red("ERROR")}: ${err.message}\n${err.stack}\n`)
+        else
+            process.stderr.write(`${pkg.name}: ${chalk.red("ERROR")}: ${err.message}`)
+    }
     process.exit(1)
 })