@jambonz/speech-utils 0.0.1

package/.eslintignore

@@ -0,0 +1 @@
+test/*

package/.eslintrc.json

@@ -0,0 +1,126 @@
+{
+  "env": {
+    "node": true,
+    "es6": true  
+  },
+  "parserOptions": {
+    "ecmaFeatures": {
+      "jsx": false,
+      "modules": false
+    },
+    "ecmaVersion": 2020
+  },
+  "plugins": ["promise"],
+  "rules": {
+    "promise/always-return": "error",
+    "promise/no-return-wrap": "error",
+    "promise/param-names": "error",
+    "promise/catch-or-return": "error",
+    "promise/no-native": "off",
+    "promise/no-nesting": "warn",
+    "promise/no-promise-in-callback": "warn",
+    "promise/no-callback-in-promise": "warn",
+    "promise/no-return-in-finally": "warn",
+
+    // Possible Errors
+    // http://eslint.org/docs/rules/#possible-errors
+    "comma-dangle": [2, "only-multiline"],
+    "no-control-regex": 2,
+    "no-debugger": 2,
+    "no-dupe-args": 2,
+    "no-dupe-keys": 2,
+    "no-duplicate-case": 2,
+    "no-empty-character-class": 2,
+    "no-ex-assign": 2,
+    "no-extra-boolean-cast" : 2,
+    "no-extra-parens": [2, "functions"],
+    "no-extra-semi": 2,
+    "no-func-assign": 2,
+    "no-invalid-regexp": 2,
+    "no-irregular-whitespace": 2,
+    "no-negated-in-lhs": 2,
+    "no-obj-calls": 2,
+    "no-proto": 2,
+    "no-unexpected-multiline": 2,
+    "no-unreachable": 2,
+    "use-isnan": 2,
+    "valid-typeof": 2,
+
+    // Best Practices
+    // http://eslint.org/docs/rules/#best-practices
+    "no-fallthrough": 2,
+    "no-octal": 2,
+    "no-redeclare": 2,
+    "no-self-assign": 2,
+    "no-unused-labels": 2,
+
+    // Strict Mode
+    // http://eslint.org/docs/rules/#strict-mode
+    "strict": [2, "never"],
+
+    // Variables
+    // http://eslint.org/docs/rules/#variables
+    "no-delete-var": 2,
+    "no-undef": 2,
+    "no-unused-vars": [2, {"args": "none"}],
+
+    // Node.js and CommonJS
+    // http://eslint.org/docs/rules/#nodejs-and-commonjs
+    "no-mixed-requires": 2,
+    "no-new-require": 2,
+    "no-path-concat": 2,
+    "no-restricted-modules": [2, "sys", "_linklist"],
+
+    // Stylistic Issues
+    // http://eslint.org/docs/rules/#stylistic-issues
+    "comma-spacing": 2,
+    "eol-last": 2,
+    "indent": [2, 2, {"SwitchCase": 1}],
+    "keyword-spacing": 2,
+    "max-len": [2, 120, 2],
+    "new-parens": 2,
+    "no-mixed-spaces-and-tabs": 2,
+    "no-multiple-empty-lines": [2, {"max": 2}],
+    "no-trailing-spaces": [2, {"skipBlankLines": false }],
+    "quotes": [2, "single", "avoid-escape"],
+    "semi": 2,
+    "space-before-blocks": [2, "always"],
+    "space-before-function-paren": [2, "never"],
+    "space-in-parens": [2, "never"],
+    "space-infix-ops": 2,
+    "space-unary-ops": 2,
+
+    // ECMAScript 6
+    // http://eslint.org/docs/rules/#ecmascript-6
+    "arrow-parens": [2, "always"],
+    "arrow-spacing": [2, {"before": true, "after": true}],
+    "constructor-super": 2,
+    "no-class-assign": 2,
+    "no-confusing-arrow": 2,
+    "no-const-assign": 2,
+    "no-dupe-class-members": 2,
+    "no-new-symbol": 2,
+    "no-this-before-super": 2,
+    "prefer-const": 2
+  },
+  "globals": {
+    "DTRACE_HTTP_CLIENT_REQUEST"           : false,
+    "LTTNG_HTTP_CLIENT_REQUEST"            : false,
+    "COUNTER_HTTP_CLIENT_REQUEST"          : false,
+    "DTRACE_HTTP_CLIENT_RESPONSE"          : false,
+    "LTTNG_HTTP_CLIENT_RESPONSE"           : false,
+    "COUNTER_HTTP_CLIENT_RESPONSE"         : false,
+    "DTRACE_HTTP_SERVER_REQUEST"           : false,
+    "LTTNG_HTTP_SERVER_REQUEST"            : false,
+    "COUNTER_HTTP_SERVER_REQUEST"          : false,
+    "DTRACE_HTTP_SERVER_RESPONSE"          : false,
+    "LTTNG_HTTP_SERVER_RESPONSE"           : false,
+    "COUNTER_HTTP_SERVER_RESPONSE"         : false,
+    "DTRACE_NET_STREAM_END"                : false,
+    "LTTNG_NET_STREAM_END"                 : false,
+    "COUNTER_NET_SERVER_CONNECTION_CLOSE"  : false,
+    "DTRACE_NET_SERVER_CONNECTION"         : false,
+    "LTTNG_NET_SERVER_CONNECTION"          : false,
+    "COUNTER_NET_SERVER_CONNECTION"        : false  
+  }
+}

package/.github/workflows/ci.yml

@@ -0,0 +1,27 @@
+name: CI
+
+on:
+  push:
+  workflow_dispatch:
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v3
+      - uses: actions/setup-node@v3
+        with:
+          node-version: lts/*
+      - run: npm install
+      - run: npm run jslint
+      - run: npm test
+        env:
+          AWS_ACCESS_KEY_ID: ${{ secrets.AWS_ACCESS_KEY_ID }}
+          AWS_REGION: ${{ secrets.AWS_REGION }}
+          AWS_SECRET_ACCESS_KEY: ${{ secrets.AWS_SECRET_ACCESS_KEY }}
+          GCP_JSON_KEY: ${{ secrets.GCP_JSON_KEY }}
+          IBM_API_KEY: ${{ secrets.IBM_API_KEY }}
+          IBM_TTS_API_KEY: ${{ secrets.IBM_TTS_API_KEY }}
+          IBM_TTS_REGION: ${{ secrets.IBM_TTS_REGION }}
+          MICROSOFT_API_KEY: ${{ secrets.MICROSOFT_API_KEY }}
+          MICROSOFT_REGION: ${{ secrets.MICROSOFT_REGION }}

package/.github/workflows/publish.yml

@@ -0,0 +1,23 @@
+name: npm-publish
+
+# run when a tag is pushed or kick off manually
+on:
+  push:
+    tags:
+      - '*'
+  workflow_dispatch:
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+
+    steps:
+      - uses: actions/checkout@v3
+      - uses: actions/setup-node@v3
+        with:
+          node-version: lts/*
+          registry-url: 'https://registry.npmjs.org'
+      - run: npm install
+      - run: npm publish --access public
+        env:
+          NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }}

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 jambonz
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,2 @@
+# speech-utils
+TTS-related speech utilities for jambonz

package/build_stubs.sh

@@ -0,0 +1,11 @@
+#!/bin/sh
+
+mkdir -p stubs/nuance
+
+for FILE in ./protos/nuance/*; do 
+  grpc_tools_node_protoc   \
+  --js_out=import_style=commonjs,binary:./stubs/nuance \
+  --grpc_out=grpc_js:./stubs/nuance \
+  --proto_path=./protos/nuance  \
+  $FILE
+done

package/config/test.json

@@ -0,0 +1,13 @@
+{
+  "logging": {
+    "level": "error"
+  },
+  "redis": {
+    "host": "127.0.0.1",
+    "port": 3379
+  },
+  "redis-auth": {
+    "host": "127.0.0.1",
+    "port": 3380
+  }
+}

package/index.js

@@ -0,0 +1,32 @@
+const {noopLogger} = require('./lib/utils');
+const promisify = require('@jambonz/promisify-redis');
+const redis = promisify(require('redis'));
+
+module.exports = (opts, logger) => {
+  const {host = '127.0.0.1', port = 6379, tls = false} = opts;
+  logger = logger || noopLogger;
+
+  const url = process.env.JAMBONES_REDIS_USERNAME && process.env.JAMBONES_REDIS_PASSWORD ?
+    `${process.env.JAMBONES_REDIS_USERNAME}:${process.env.JAMBONES_REDIS_PASSWORD}@${host}:${port}` :
+    `${host}:${port}`;
+  const client = redis.createClient(tls ? `rediss://${url}` : `redis://${url}`);
+  ['ready', 'connect', 'reconnecting', 'error', 'end', 'warning']
+    .forEach((event) => {
+      client.on(event, (...args) => {
+        if ('error' === event) {
+          if (process.env.NODE_ENV === 'test' && args[0]?.code === 'ECONNREFUSED') return;
+          logger.error({...args}, '@jambonz/realtimedb-helpers - redis error');
+        }
+        else logger.debug({args}, `redis event ${event}`);
+      });
+    });
+
+  return {
+    client,
+    purgeTtsCache: require('./lib/purge-tts-cache').bind(null, client, logger),
+    synthAudio: require('./lib/synth-audio').bind(null, client, logger),
+    getNuanceAccessToken: require('./lib/get-nuance-access-token').bind(null, client, logger),
+    getIbmAccessToken: require('./lib/get-ibm-access-token').bind(null, client, logger),
+    getTtsVoices: require('./lib/get-tts-voices').bind(null, client, logger),
+  };
+};

package/lib/get-ibm-access-token.js

@@ -0,0 +1,48 @@
+const formurlencoded = require('form-urlencoded');
+const {Pool} = require('undici');
+const pool = new Pool('https://iam.cloud.ibm.com');
+const {makeIbmKey, noopLogger} = require('./utils');
+const debug = require('debug')('jambonz:realtimedb-helpers');
+const HTTP_TIMEOUT = 5000;
+
+async function getIbmAccessToken(client, logger, apiKey) {
+  logger = logger || noopLogger;
+  try {
+    const key = makeIbmKey(apiKey);
+    const access_token = await client.getAsync(key);
+    if (access_token) return {access_token, servedFromCache: true};
+
+    /* access token not found in cache, so fetch it from Ibm */
+    const payload = {
+      grant_type: 'urn:ibm:params:oauth:grant-type:apikey',
+      apikey: apiKey
+    };
+    const {statusCode, headers, body} =  await pool.request({
+      path: '/identity/token',
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/x-www-form-urlencoded'
+      },
+      body: formurlencoded(payload),
+      timeout: HTTP_TIMEOUT,
+      followRedirects: false
+    });
+
+    if (200 !== statusCode) {
+      const json = await body.json();
+      logger.debug({statusCode, headers, body: json}, 'error fetching access token from Ibm');
+      const err = new Error();
+      err.statusCode = statusCode;
+      throw err;
+    }
+    const json = await body.json();
+    await client.set(key, json.access_token, 'EX', json.expires_in - 30);
+    return {...json, servedFromCache: false};
+  } catch (err) {
+    debug(err, 'getIbmAccessToken: Error retrieving Ibm access token');
+    logger.error(err, 'getIbmAccessToken: Error retrieving Ibm access token for client_id ${clientId}');
+    throw err;
+  }
+}
+
+module.exports = getIbmAccessToken;

package/lib/get-nuance-access-token.js

@@ -0,0 +1,49 @@
+const formurlencoded = require('form-urlencoded');
+const {Pool} = require('undici');
+const pool = new Pool('https://auth.crt.nuance.com');
+const {makeNuanceKey, makeBasicAuthHeader, noopLogger} = require('./utils');
+const debug = require('debug')('jambonz:realtimedb-helpers');
+const HTTP_TIMEOUT = 5000;
+
+async function getNuanceAccessToken(client, logger, clientId, secret, scope) {
+  logger = logger || noopLogger;
+  try {
+    const key = makeNuanceKey(clientId, secret, scope);
+    const access_token = await client.getAsync(key);
+    if (access_token) return {access_token, servedFromCache: true};
+
+    /* access token not found in cache, so fetch it from Nuance */
+    const payload = {
+      grant_type: 'client_credentials',
+      scope
+    };
+    const auth = makeBasicAuthHeader(clientId, secret);
+    const {statusCode, headers, body} =  await pool.request({
+      path: '/oauth2/token',
+      method: 'POST',
+      headers: {
+        ...auth,
+        'Content-Type': 'application/x-www-form-urlencoded'
+      },
+      body: formurlencoded(payload),
+      timeout: HTTP_TIMEOUT,
+      followRedirects: false
+    });
+
+    if (200 !== statusCode) {
+      logger.debug({statusCode, headers, body: body.text()}, 'error fetching access token from Nuance');
+      const err = new Error();
+      err.statusCode = statusCode;
+      throw err;
+    }
+    const json = await body.json();
+    await client.set(key, json.access_token, 'EX', json.expires_in - 30);
+    return {...json, servedFromCache: false};
+  } catch (err) {
+    debug(err, `getNuanceAccessToken: Error retrieving Nuance access token for client_id ${clientId}`);
+    logger.error(err, `getNuanceAccessToken: Error retrieving Nuance access token for client_id ${clientId}`);
+    throw err;
+  }
+}
+
+module.exports = getNuanceAccessToken;

package/lib/get-tts-voices.js

@@ -0,0 +1,111 @@
+const assert = require('assert');
+const {noopLogger, createNuanceClient} = require('./utils');
+const getNuanceAccessToken = require('./get-nuance-access-token');
+const {GetVoicesRequest, Voice} = require('../stubs/nuance/synthesizer_pb');
+const TextToSpeechV1 = require('ibm-watson/text-to-speech/v1');
+const { IamAuthenticator } = require('ibm-watson/auth');
+
+const getIbmVoices = async(client, logger, credentials) => {
+  const {tts_region, tts_api_key} = credentials;
+  console.log(`region: ${tts_region}, api_key: ${tts_api_key}`);
+
+  const textToSpeech = new TextToSpeechV1({
+    authenticator: new IamAuthenticator({
+      apikey: tts_api_key,
+    }),
+    serviceUrl: `https://api.${tts_region}.text-to-speech.watson.cloud.ibm.com`
+  });
+
+  const voices = await textToSpeech.listVoices();
+  return voices;
+};
+
+const getNuanceVoices = async(client, logger, credentials) => {
+  const {client_id: clientId, secret: secret} = credentials;
+
+  return new Promise(async(resolve, reject) => {
+    /* get a nuance access token */
+    let token, nuanceClient;
+    try {
+      const access_token = await getNuanceAccessToken(client, logger, clientId, secret, 'tts');
+      token = access_token.access_token;
+      nuanceClient = await createNuanceClient(token);
+    } catch (err) {
+      logger.error({err}, 'getTtsVoices: error retrieving access token');
+      return reject(err);
+    }
+    /* retrieve all voices */
+    const v = new Voice();
+    const request = new GetVoicesRequest();
+    request.setVoice(v);
+
+    nuanceClient.getVoices(request, (err, response) => {
+      if (err) {
+        logger.error({err, clientId, secret, token}, 'getTtsVoices: error retrieving voices');
+        return reject(err);
+      }
+
+      /* return all the voices that are not restricted and eliminate duplicates */
+      const voices = response.getVoicesList()
+        .map((v) => {
+          return {
+            language: v.getLanguage(),
+            name: v.getName(),
+            model: v.getModel(),
+            gender: v.getGender() === 1 ? 'male' : 'female',
+            restricted: v.getRestricted()
+          };
+        });
+      const v = voices
+        .filter((v) => v.restricted === false)
+        .map((v) => {
+          delete v.restricted;
+          return v;
+        })
+        .sort((a, b) => {
+          if (a.language < b.language) return -1;
+          if (a.language > b.language) return 1;
+          if (a.name < b.name) return -1;
+          return 1;
+        });
+      const arr = [...new Set(v.map((v) => JSON.stringify(v)))]
+        .map((v) => JSON.parse(v));
+      resolve(arr);
+    });
+  });
+};
+
+/**
+ * Synthesize speech to an mp3 file, and also cache the generated speech
+ * in redis (base64 format) for 24 hours so as to avoid unnecessarily paying
+ * time and again for speech synthesis of the same text.
+ * It is the responsibility of the caller to unlink the mp3 file after use.
+ *
+ * @param {*} client - redis client
+ * @param {*} logger - pino logger
+ * @param {object} opts - options
+ * @param {string} opts.vendor - 'google' or 'aws' ('polly' is an alias for 'aws')
+ * @param {string} opt.language - language code
+ * @param {string} opts.voice - voice identifier
+ * @param {string} opts.text - text or ssml to synthesize
+ * @returns object containing filepath to an mp3 file in the /tmp folder containing
+ * the synthesized audio, and a variable indicating whether it was served from cache
+ */
+async function getTtsVoices(client, logger, {vendor, credentials}) {
+  logger = logger || noopLogger;
+
+  assert.ok(['nuance', 'ibm'].includes(vendor),
+    `getTtsVoices not supported for vendor ${vendor}`);
+
+  switch (vendor) {
+    case 'nuance':
+      return getNuanceVoices(client, logger, credentials);
+    case 'ibm':
+      return getIbmVoices(client, logger, credentials);
+    default:
+      break;
+  }
+}
+
+
+module.exports = getTtsVoices;

package/lib/purge-tts-cache.js

@@ -0,0 +1,46 @@
+const {noopLogger, makeSynthKey} = require('./utils');
+const debug = require('debug')('jambonz:realtimedb-helpers');
+
+/**
+ * Scan TTS Cache and purge records, use specific settings to purge just one
+ * @param {object} opts - options
+ * @param {boolean} opts.all - purge all records or only one specific, true by default
+ * @param {string} opts.vendor - 'google' or 'aws' ('polly' is an alias for 'aws')
+ * @param {string} opts.language - language code
+ * @param {string} opts.voice - voice identifier
+ * @param {string} opts.text - text or ssml to synthesize
+ * @returns {object} result - {error, purgedCount}
+ */
+async function purgeTtsCache(client, logger, {all, vendor, language, voice, deploymentId, engine, text} = {all: true}) {
+  logger = logger || noopLogger;
+
+  let purgedCount = 0, error;
+
+  try {
+    if (all) {
+      const keys = await client.keysAsync('tts:*');
+      purgedCount = await client.delAsync(keys);
+
+    } else {
+      const key = makeSynthKey({
+        vendor,
+        language: language || '',
+        voice: voice || deploymentId,
+        engine,
+        text,
+      });
+      purgedCount = await client.delAsync(key);
+      if (purgedCount === 0) error = 'Specified item not found';
+    }
+
+  } catch (err) {
+    debug(err, 'purgeTtsCache: Error');
+    logger.error(err, 'purgeTtsCache: Error');
+    error = err.message ?? 'Unknown Error';
+  }
+
+  logger.info(`purgeTtsCache: purged ${purgedCount} records`);
+  return {error, purgedCount};
+}
+
+module.exports = purgeTtsCache;