speechflow 1.4.2 → 1.4.4

package/speechflow-cli/dst/speechflow.js

@@ -0,0 +1,837 @@
+#!/usr/bin/env node
+"use strict";
+/*!
+**  SpeechFlow - Speech Processing Flow Graph
+**  Copyright (c) 2024-2025 Dr. Ralf S. Engelschall <rse@engelschall.com>
+**  Licensed under GPL 3.0 <https://spdx.org/licenses/GPL-3.0-only>
+*/
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+/*  standard dependencies  */
+const node_path_1 = __importDefault(require("node:path"));
+const node_stream_1 = __importDefault(require("node:stream"));
+const node_events_1 = require("node:events");
+const HAPI = __importStar(require("@hapi/hapi"));
+const inert_1 = __importDefault(require("@hapi/inert"));
+const ws_1 = __importDefault(require("ws"));
+const hapi_plugin_websocket_1 = __importDefault(require("hapi-plugin-websocket"));
+const hapi_plugin_header_1 = __importDefault(require("hapi-plugin-header"));
+/*  external dependencies  */
+const luxon_1 = require("luxon");
+const cli_io_1 = __importDefault(require("cli-io"));
+const yargs_1 = __importDefault(require("yargs"));
+const helpers_1 = require("yargs/helpers");
+const js_yaml_1 = __importDefault(require("js-yaml"));
+const flowlink_1 = __importDefault(require("flowlink"));
+const object_path_1 = __importDefault(require("object-path"));
+const installed_packages_1 = __importDefault(require("installed-packages"));
+const dotenvx_1 = __importDefault(require("@dotenvx/dotenvx"));
+const syspath_1 = __importDefault(require("syspath"));
+const arktype = __importStar(require("arktype"));
+const cli_table3_1 = __importDefault(require("cli-table3"));
+const chalk_1 = __importDefault(require("chalk"));
+const package_json_1 = __importDefault(require("../../package.json"));
+/*  central CLI context  */
+let cli = null;
+(async () => {
+    /*  determine system paths  */
+    const { dataDir } = (0, syspath_1.default)({
+        appName: "speechflow",
+        dataDirAutoCreate: true
+    });
+    /*  parse command-line arguments  */
+    const coerce = (arg) => Array.isArray(arg) ? arg[arg.length - 1] : arg;
+    const args = await (0, yargs_1.default)()
+        /* eslint @stylistic/indent: off */
+        .usage("Usage: $0 " +
+        "[-h|--help] " +
+        "[-V|--version] " +
+        "[-S|--status] " +
+        "[-v|--verbose <level>] " +
+        "[-a|--address <ip-address>] " +
+        "[-p|--port <tcp-port>] " +
+        "[-C|--cache <directory>] " +
+        "[-d|--dashboard <type>:<id>:<name>[,...]] " +
+        "[-e|--expression <expression>] " +
+        "[-f|--file <file>] " +
+        "[-c|--config <id>@<yaml-config-file>] " +
+        "[<argument> [...]]")
+        .version(false)
+        .option("V", {
+        alias: "version",
+        type: "boolean",
+        array: false,
+        coerce,
+        default: false,
+        describe: "show program version information"
+    })
+        .option("S", {
+        alias: "status",
+        type: "boolean",
+        array: false,
+        coerce,
+        default: false,
+        describe: "show one-time status of nodes"
+    })
+        .option("v", {
+        alias: "log-level",
+        type: "string",
+        array: false,
+        coerce,
+        nargs: 1,
+        default: "warning",
+        describe: "level for verbose logging ('none', 'error', 'warning', 'info', 'debug')"
+    })
+        .option("a", {
+        alias: "address",
+        type: "string",
+        array: false,
+        coerce,
+        nargs: 1,
+        default: "0.0.0.0",
+        describe: "IP address for REST/WebSocket API"
+    })
+        .option("p", {
+        alias: "port",
+        type: "number",
+        array: false,
+        coerce,
+        nargs: 1,
+        default: 8484,
+        describe: "TCP port for REST/WebSocket API"
+    })
+        .option("C", {
+        alias: "cache",
+        type: "string",
+        array: false,
+        coerce,
+        nargs: 1,
+        default: node_path_1.default.join(dataDir, "cache"),
+        describe: "directory for cached files (primarily AI model files)"
+    })
+        .option("d", {
+        alias: "dashboard",
+        type: "string",
+        array: false,
+        coerce,
+        nargs: 1,
+        default: "",
+        describe: "list of dashboard block types and names"
+    })
+        .option("e", {
+        alias: "expression",
+        type: "string",
+        array: false,
+        coerce,
+        nargs: 1,
+        default: "",
+        describe: "FlowLink expression string"
+    })
+        .option("f", {
+        alias: "file",
+        type: "string",
+        array: false,
+        coerce,
+        nargs: 1,
+        default: "",
+        describe: "FlowLink expression file"
+    })
+        .option("c", {
+        alias: "config",
+        type: "string",
+        array: false,
+        coerce,
+        nargs: 1,
+        default: "",
+        describe: "FlowLink expression reference into YAML file (in format <id>@<file>)"
+    })
+        .help("h", "show usage help")
+        .alias("h", "help")
+        .showHelpOnFail(true)
+        .strict()
+        .demand(0)
+        .parse((0, helpers_1.hideBin)(process.argv));
+    /*  short-circuit version request  */
+    if (args.V) {
+        process.stderr.write(`SpeechFlow ${package_json_1.default["x-stdver"]} (${package_json_1.default["x-release"]}) <${package_json_1.default.homepage}>\n`);
+        process.stderr.write(`${package_json_1.default.description}\n`);
+        process.stderr.write(`Copyright (c) 2024-2025 ${package_json_1.default.author.name} <${package_json_1.default.author.url}>\n`);
+        process.stderr.write(`Licensed under ${package_json_1.default.license} <http://spdx.org/licenses/${package_json_1.default.license}.html>\n`);
+        process.exit(0);
+    }
+    /*  establish CLI environment  */
+    cli = new cli_io_1.default({
+        encoding: "utf8",
+        logLevel: args.v,
+        logTime: true,
+        logPrefix: package_json_1.default.name
+    });
+    /*  catch uncaught exceptions  */
+    process.on("uncaughtException", (err) => {
+        cli.log("error", `uncaught exception: ${err.message}\n${err.stack}`);
+        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}`);
+        else
+            cli.log("error", `unhandled rejection: ${reason}`);
+        process.exit(1);
+    });
+    /*  provide startup information  */
+    cli.log("info", `starting SpeechFlow ${package_json_1.default["x-stdver"]} (${package_json_1.default["x-release"]})`);
+    /*  load .env files  */
+    const result = dotenvx_1.default.config({ encoding: "utf8", quiet: true });
+    if (result?.parsed !== undefined)
+        for (const key of Object.keys(result.parsed))
+            cli.log("info", `loaded environment variable "${key}" from ".env" files`);
+    /*  sanity check usage  */
+    let n = 0;
+    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)");
+    /*  read configuration  */
+    let config = "";
+    if (typeof args.e === "string" && args.e !== "")
+        config = args.e;
+    else if (typeof args.f === "string" && args.f !== "")
+        config = await cli.input(args.f, { encoding: "utf8" });
+    else if (typeof args.c === "string" && args.c !== "") {
+        const m = args.c.match(/^(.+?)@(.+)$/);
+        if (m === null)
+            throw new Error("invalid configuration file specification (expected \"<id>@<yaml-config-file>\")");
+        const [, id, file] = m;
+        const yaml = await cli.input(file, { encoding: "utf8" });
+        let obj;
+        try {
+            obj = js_yaml_1.default.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 "${file}"`);
+        config = obj[id];
+    }
+    /*  track the available SpeechFlow nodes  */
+    const nodes = {};
+    /*  load internal SpeechFlow nodes  */
+    const pkgsI = [
+        "./speechflow-node-a2a-ffmpeg.js",
+        "./speechflow-node-a2a-gender.js",
+        "./speechflow-node-a2a-meter.js",
+        "./speechflow-node-a2a-mute.js",
+        "./speechflow-node-a2a-vad.js",
+        "./speechflow-node-a2a-wav.js",
+        "./speechflow-node-a2t-deepgram.js",
+        "./speechflow-node-t2a-elevenlabs.js",
+        "./speechflow-node-t2a-kokoro.js",
+        "./speechflow-node-t2t-deepl.js",
+        "./speechflow-node-t2t-format.js",
+        "./speechflow-node-t2t-ollama.js",
+        "./speechflow-node-t2t-openai.js",
+        "./speechflow-node-t2t-sentence.js",
+        "./speechflow-node-t2t-subtitle.js",
+        "./speechflow-node-t2t-transformers.js",
+        "./speechflow-node-x2x-filter.js",
+        "./speechflow-node-x2x-trace.js",
+        "./speechflow-node-xio-device.js",
+        "./speechflow-node-xio-file.js",
+        "./speechflow-node-xio-mqtt.js",
+        "./speechflow-node-xio-websocket.js"
+    ];
+    for (const pkg of pkgsI) {
+        let node = await import(pkg);
+        while (node.default !== undefined)
+            node = node.default;
+        if (typeof node === "function" && typeof node.name === "string") {
+            cli.log("info", `loading SpeechFlow node <${node.name}> from internal module`);
+            nodes[node.name] = node;
+        }
+    }
+    /*  load external SpeechFlow nodes  */
+    const pkgsE = await (0, installed_packages_1.default)();
+    for (const pkg of pkgsE) {
+        if (pkg.match(/^(?:@[^/]+\/)?speechflow-node-.+$/)) {
+            let node = await import(pkg);
+            while (node.default !== undefined)
+                node = node.default;
+            if (typeof node === "function" && typeof node.name === "string") {
+                if (nodes[node.name] !== undefined) {
+                    cli.log("warning", `failed loading SpeechFlow node <${node.name}> ` +
+                        `from external module "${pkg}" -- node already exists`);
+                    continue;
+                }
+                cli.log("info", `loading SpeechFlow node <${node.name}> from external module "${pkg}"`);
+                nodes[node.name] = node;
+            }
+        }
+    }
+    /*  static configuration  */
+    const cfg = {
+        audioChannels: 1,
+        audioBitDepth: 16,
+        audioLittleEndian: true,
+        audioSampleRate: 48000,
+        textEncoding: "utf8",
+        cacheDir: args.C
+    };
+    /*  handle one-time status query of nodes  */
+    if (args.S) {
+        const table = new cli_table3_1.default({
+            head: [
+                chalk_1.default.reset.bold("NODE"),
+                chalk_1.default.reset.bold("PROPERTY"),
+                chalk_1.default.reset.bold("VALUE")
+            ],
+            colWidths: [15, 15, 50 - (2 * 2 + 2 * 3)],
+            style: { "padding-left": 1, "padding-right": 1, border: ["grey"], compact: true },
+            chars: { "left-mid": "", mid: "", "mid-mid": "", "right-mid": "" }
+        });
+        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 Promise.race([
+                node.status(),
+                new Promise((resolve, reject) => setTimeout(() => reject(new Error("timeout")), 10 * 1000))
+            ]).catch((err) => {
+                cli.log("warning", `[${node.id}]: failed to gather status of node <${node.id}>: ${err.message}`);
+                return {};
+            });
+            if (Object.keys(status).length > 0) {
+                let first = true;
+                for (const key of Object.keys(status)) {
+                    table.push([first ? chalk_1.default.bold(name) : "", key, chalk_1.default.blue(status[key])]);
+                    first = false;
+                }
+            }
+        }
+        const output = table.toString();
+        process.stdout.write(output + "\n");
+        process.exit(0);
+    }
+    /*  graph processing: PASS 1: parse DSL and create and connect nodes  */
+    const flowlink = new flowlink_1.default({
+        trace: (msg) => {
+            cli.log("debug", msg);
+        }
+    });
+    const variables = { argv: args._, env: process.env };
+    const graphNodes = new Set();
+    const nodeNums = new Map();
+    let ast;
+    try {
+        ast = flowlink.compile(config);
+    }
+    catch (err) {
+        const errorMsg = err instanceof Error && err.name === "FlowLinkError"
+            ? err.toString() : (err instanceof Error ? err.message : "internal error");
+        cli.log("error", `failed to parse SpeechFlow configuration: ${errorMsg}`);
+        process.exit(1);
+    }
+    try {
+        flowlink.execute(ast, {
+            resolveVariable(id) {
+                if (!object_path_1.default.has(variables, id))
+                    throw new Error(`failed to resolve variable "${id}"`);
+                const value = object_path_1.default.get(variables, id);
+                cli.log("info", `resolve variable: "${id}" -> "${value}"`);
+                return value;
+            },
+            createNode(id, opts, args) {
+                if (nodes[id] === undefined)
+                    throw new Error(`unknown node <${id}>`);
+                let node;
+                try {
+                    const NodeClass = nodes[id];
+                    let num = nodeNums.get(NodeClass) ?? 0;
+                    nodeNums.set(NodeClass, ++num);
+                    const name = num === 1 ? id : `${id}:${num}`;
+                    node = new NodeClass(name, cfg, opts, args);
+                }
+                catch (err) {
+                    /*  fatal error  */
+                    if (err instanceof Error)
+                        cli.log("error", `creation of node <${id}> failed: ${err.message}`);
+                    else
+                        cli.log("error", `creation of node <${id}> failed: ${err}`);
+                    process.exit(1);
+                }
+                const params = Object.keys(node.params)
+                    .map((key) => `${key}: ${JSON.stringify(node.params[key])}`).join(", ");
+                cli.log("info", `create node <${node.id}> (${params})`);
+                graphNodes.add(node);
+                return node;
+            },
+            connectNode(node1, node2) {
+                cli.log("info", `connect node <${node1.id}> to node <${node2.id}>`);
+                node1.connect(node2);
+            }
+        });
+    }
+    catch (err) {
+        const errorMsg = err instanceof Error && err.name === "FlowLinkError"
+            ? err.toString() : (err instanceof Error ? err.message : "internal error");
+        cli.log("error", `failed to materialize SpeechFlow configuration: ${errorMsg}`);
+        process.exit(1);
+    }
+    /*  graph processing: PASS 2: prune connections of nodes  */
+    for (const node of graphNodes) {
+        /*  determine connections  */
+        let connectionsIn = Array.from(node.connectionsIn);
+        let connectionsOut = Array.from(node.connectionsOut);
+        /*  ensure necessary incoming links  */
+        if (node.input !== "none" && connectionsIn.length === 0)
+            throw new Error(`node <${node.id}> requires input but has no input nodes connected`);
+        /*  prune unnecessary incoming links  */
+        if (node.input === "none" && connectionsIn.length > 0)
+            connectionsIn.forEach((other) => { other.disconnect(node); });
+        /*  ensure necessary outgoing links  */
+        if (node.output !== "none" && connectionsOut.length === 0)
+            throw new Error(`node <${node.id}> requires output but has no output nodes connected`);
+        /*  prune unnecessary outgoing links  */
+        if (node.output === "none" && connectionsOut.length > 0)
+            connectionsOut.forEach((other) => { node.disconnect(other); });
+        /*  check for payload compatibility  */
+        connectionsIn = Array.from(node.connectionsIn);
+        connectionsOut = Array.from(node.connectionsOut);
+        for (const other of connectionsOut)
+            if (other.input !== node.output)
+                throw new Error(`${node.output} output node <${node.id}> cannot be ` +
+                    `connected to ${other.input} input node <${other.id}> (payload is incompatible)`);
+    }
+    /*  graph processing: PASS 3: open nodes  */
+    const timeZero = luxon_1.DateTime.now();
+    for (const node of graphNodes) {
+        /*  connect node events  */
+        node.on("log", (level, msg, data) => {
+            let str = `<${node.id}>: ${msg}`;
+            if (data !== undefined)
+                str += ` (${JSON.stringify(data)})`;
+            cli.log(level, str);
+        });
+        /*  open node  */
+        cli.log("info", `open node <${node.id}>`);
+        node.setTimeZero(timeZero);
+        await Promise.race([
+            node.open(),
+            new Promise((resolve, reject) => setTimeout(() => reject(new Error("timeout")), 10 * 1000))
+        ]).catch((err) => {
+            cli.log("error", `[${node.id}]: failed to open node <${node.id}>: ${err.message}`);
+            throw new Error(`failed to open node <${node.id}>: ${err.message}`);
+        });
+    }
+    /*  graph processing: PASS 4: connect node streams  */
+    for (const node of graphNodes) {
+        if (node.stream === null)
+            throw new Error(`stream of node <${node.id}> still not initialized`);
+        for (const other of Array.from(node.connectionsOut)) {
+            if (other.stream === null)
+                throw new Error(`stream of incoming node <${other.id}> still not initialized`);
+            cli.log("info", `connect stream of node <${node.id}> to stream of node <${other.id}>`);
+            if (!(node.stream instanceof node_stream_1.default.Readable
+                || node.stream instanceof node_stream_1.default.Duplex))
+                throw new Error(`stream of output node <${node.id}> is neither of Readable nor Duplex type`);
+            if (!(other.stream instanceof node_stream_1.default.Writable
+                || other.stream instanceof node_stream_1.default.Duplex))
+                throw new Error(`stream of input node <${other.id}> is neither of Writable nor Duplex type`);
+            node.stream.pipe(other.stream);
+        }
+    }
+    /*  graph processing: PASS 5: track stream finishing  */
+    const activeNodes = new Set();
+    const finishEvents = new node_events_1.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`);
+        cli.log("info", `observe stream of node <${node.id}> for finish event`);
+        activeNodes.add(node);
+        const deactivateNode = (node, msg) => {
+            if (activeNodes.has(node))
+                activeNodes.delete(node);
+            cli.log("info", `${msg} (${activeNodes.size} active nodes remaining)`);
+            if (activeNodes.size === 0) {
+                const timeFinished = luxon_1.DateTime.now();
+                const duration = timeFinished.diff(timeZero);
+                cli.log("info", "**** everything finished -- stream processing in SpeechFlow graph stops " +
+                    `(total duration: ${duration.toFormat("hh:mm:ss.SSS")}) ****`);
+                finishEvents.emit("finished");
+            }
+        };
+        node.stream.on("end", () => {
+            deactivateNode(node, `readable stream side of node <${node.id}> raised "end" event`);
+        });
+        node.stream.on("finish", () => {
+            deactivateNode(node, `writable stream side of node <${node.id}> raised "finish" event`);
+        });
+    }
+    /*  define external request/response structure  */
+    const requestValidator = arktype.type({
+        request: "string",
+        node: "string",
+        args: "unknown[]"
+    });
+    /*  forward external request to target node in graph  */
+    const consumeExternalRequest = async (_req) => {
+        const req = requestValidator(_req);
+        if (req instanceof arktype.type.errors)
+            throw new Error(`invalid request: ${req.summary}`);
+        if (req.request !== "COMMAND")
+            throw new Error("invalid external request (command expected)");
+        const name = req.node;
+        const args = req.args;
+        const foundNode = Array.from(graphNodes).find((node) => node.id === name);
+        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 Promise.race([
+                foundNode.receiveRequest(args),
+                new Promise((resolve, reject) => setTimeout(() => reject(new Error("timeout")), 10 * 1000))
+            ]).catch((err) => {
+                cli.log("warning", `external request to node <${name}> failed: ${err.message}`);
+            });
+        }
+    };
+    /*  establish REST/WebSocket API  */
+    const wsPeers = new Map();
+    const hapi = new HAPI.Server({
+        address: args.a,
+        port: args.p
+    });
+    await hapi.register({ plugin: inert_1.default });
+    await hapi.register({ plugin: hapi_plugin_header_1.default, options: { Server: `${package_json_1.default.name}/${package_json_1.default.version}` } });
+    await hapi.register({ plugin: hapi_plugin_websocket_1.default });
+    hapi.events.on("response", (request) => {
+        let protocol = `HTTP/${request.raw.req.httpVersion}`;
+        const ws = request.websocket();
+        if (ws.mode === "websocket") {
+            const wsVersion = ws.ws.protocolVersion ??
+                request.headers["sec-websocket-version"] ?? "13?";
+            protocol = `WebSocket/${wsVersion}+${protocol}`;
+        }
+        const msg = "remote=" + request.info.remoteAddress + ", " +
+            "method=" + request.method.toUpperCase() + ", " +
+            "url=" + request.url.pathname + ", " +
+            "protocol=" + protocol + ", " +
+            "response=" + ("statusCode" in request.response ? request.response.statusCode : "<unknown>");
+        cli.log("info", `HAPI: request: ${msg}`);
+    });
+    hapi.events.on({ name: "request", channels: ["error"] }, (request, event, tags) => {
+        if (event.error instanceof Error)
+            cli.log("error", `HAPI: request-error: ${event.error.message}`);
+        else
+            cli.log("error", `HAPI: request-error: ${event.error}`);
+    });
+    hapi.events.on("log", (event, tags) => {
+        if (tags.error) {
+            const err = event.error;
+            if (err instanceof Error)
+                cli.log("error", `HAPI: log: ${err.message}`);
+            else
+                cli.log("error", `HAPI: log: ${err}`);
+        }
+    });
+    hapi.route({
+        method: "GET",
+        path: "/{param*}",
+        handler: {
+            directory: {
+                path: node_path_1.default.join(__dirname, "../../speechflow-ui-db/dst"),
+                redirectToSlash: true,
+                index: true
+            }
+        }
+    });
+    hapi.route({
+        method: "GET",
+        path: "/api/dashboard",
+        handler: (request, h) => {
+            const config = [];
+            for (const block of args.d.split(",")) {
+                const [type, id, name] = block.split(":");
+                config.push({ type, id, name });
+            }
+            return h.response(config).code(200);
+        }
+    });
+    hapi.route({
+        method: "GET",
+        path: "/api/{req}/{node}/{params*}",
+        options: {},
+        handler: (request, h) => {
+            const peer = request.info.remoteAddress;
+            const params = request.params.params ?? "";
+            if (params.length > 1000)
+                return h.response({ response: "ERROR", data: "parameters too long" }).code(400);
+            const req = {
+                request: request.params.req,
+                node: request.params.node,
+                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);
+            });
+        }
+    });
+    hapi.route({
+        method: "POST",
+        path: "/api",
+        options: {
+            payload: {
+                output: "data",
+                parse: true,
+                allow: "application/json",
+                maxBytes: 1 * 1024 * 1024
+            },
+            plugins: {
+                websocket: {
+                    autoping: 30 * 1000,
+                    connect: (args) => {
+                        const ctx = args.ctx;
+                        const ws = args.ws;
+                        const req = args.req;
+                        const peer = `${req.socket.remoteAddress}:${req.socket.remotePort}`;
+                        ctx.peer = peer;
+                        wsPeers.set(peer, { ctx, ws, req });
+                        cli.log("info", `HAPI: WebSocket: connect: peer ${peer}`);
+                    },
+                    disconnect: (args) => {
+                        const ctx = args.ctx;
+                        const ws = args.ws;
+                        const peer = ctx.peer;
+                        wsPeers.delete(peer);
+                        ws.removeAllListeners();
+                        cli.log("info", `HAPI: WebSocket: disconnect: peer ${peer}`);
+                    }
+                }
+            }
+        },
+        handler: (request, h) => {
+            /*  on WebSocket message transfer  */
+            const peer = request.info.remoteAddress;
+            const req = requestValidator(request.payload);
+            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) => {
+                return h.response({ response: "ERROR", data: err.message }).code(417);
+            });
+        }
+    });
+    await hapi.start();
+    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) {
+        node.on("send-response", (args) => {
+            const data = JSON.stringify({ response: "NOTIFY", node: node.id, args });
+            for (const [peer, info] of wsPeers.entries()) {
+                cli.log("debug", `HAPI: remote peer ${peer}: sending ${data}`);
+                if (info.ws.readyState === ws_1.default.OPEN)
+                    info.ws.send(data);
+            }
+        });
+    }
+    /*  hook for dashboardInfo method of nodes  */
+    for (const node of graphNodes) {
+        node.on("dashboard-info", (info) => {
+            const data = JSON.stringify({
+                response: "DASHBOARD",
+                node: "",
+                args: [info.type, info.id, info.kind, info.value]
+            });
+            for (const [peer, info] of wsPeers.entries()) {
+                cli.log("debug", `HAPI: dashboard peer ${peer}: send ${data}`);
+                info.ws.send(data);
+            }
+        });
+    }
+    /*  start of internal stream processing  */
+    cli.log("info", "**** everything established -- stream processing in SpeechFlow graph starts ****");
+    /*  gracefully shutdown process  */
+    let shuttingDown = false;
+    const shutdown = async (signal) => {
+        if (shuttingDown)
+            return;
+        shuttingDown = true;
+        if (signal === "finished")
+            cli.log("info", "**** streams of all nodes finished -- shutting down service ****");
+        else if (signal === "exception")
+            cli.log("warning", "**** exception occurred -- shutting down service ****");
+        else
+            cli.log("warning", `**** received signal ${signal} -- shutting down service ****`);
+        /*  shutdown HAPI service  */
+        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 = [];
+            for (const [peer, info] of wsPeers.entries()) {
+                closePromises.push(new Promise((resolve, reject) => {
+                    if (info.ws.readyState !== ws_1.default.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) {
+                cli.log("warning", `stream of node <${node.id}> no longer initialized`);
+                continue;
+            }
+            for (const other of Array.from(node.connectionsOut)) {
+                if (other.stream === null) {
+                    cli.log("warning", `stream of incoming node <${other.id}> no longer initialized`);
+                    continue;
+                }
+                if (!(node.stream instanceof node_stream_1.default.Readable
+                    || node.stream instanceof node_stream_1.default.Duplex)) {
+                    cli.log("warning", `stream of output node <${node.id}> is neither of Readable nor Duplex type`);
+                    continue;
+                }
+                if (!(other.stream instanceof node_stream_1.default.Writable
+                    || other.stream instanceof node_stream_1.default.Duplex)) {
+                    cli.log("warning", `stream of input node <${other.id}> is neither of Writable nor Duplex type`);
+                    continue;
+                }
+                cli.log("info", `disconnect stream of node <${node.id}> from stream of node <${other.id}>`);
+                node.stream.unpipe(other.stream);
+            }
+        }
+        /*  graph processing: PASS 2: close nodes  */
+        for (const node of graphNodes) {
+            cli.log("info", `close node <${node.id}>`);
+            await Promise.race([
+                node.close(),
+                new Promise((resolve, reject) => setTimeout(() => reject(new Error("timeout")), 10 * 1000))
+            ]).catch((err) => {
+                cli.log("warning", `node <${node.id}> failed to close: ${err.message}`);
+            });
+        }
+        /*  graph processing: PASS 3: disconnect nodes  */
+        for (const node of graphNodes) {
+            cli.log("info", `disconnect node <${node.id}>`);
+            const connectionsIn = Array.from(node.connectionsIn);
+            const connectionsOut = Array.from(node.connectionsOut);
+            connectionsIn.forEach((other) => { other.disconnect(node); });
+            connectionsOut.forEach((other) => { node.disconnect(other); });
+        }
+        /*  graph processing: PASS 4: shutdown nodes  */
+        for (const node of graphNodes) {
+            cli.log("info", `destroy node <${node.id}>`);
+            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)");
+            process.exit(0);
+        }
+        else {
+            cli.log("info", "terminate process (exit code 1)");
+            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.message}\n${err.stack}`);
+        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}`);
+        else
+            cli.log("error", `unhandled rejection: ${reason}`);
+        shutdown("exception");
+    });
+})().catch((err) => {
+    /*  top-level exception handling  */
+    if (cli !== null)
+        cli.log("error", `${err.message}:\n${err.stack}`);
+    else
+        process.stderr.write(`${package_json_1.default.name}: ${chalk_1.default.red("ERROR")}: ${err.message}\n${err.stack}\n`);
+    process.exit(1);
+});
+//# sourceMappingURL=speechflow.js.map