echogarden 1.1.0 → 1.2.0

package/dist/cli/CLI.js

@@ -23,6 +23,7 @@ import { startServer } from '../server/Server.js';
 import { OpenPromise } from '../utilities/OpenPromise.js';
 import JSON5 from 'json5';
 import { getLowercaseFileExtension, resolveToModuleRootDir } from '../utilities/PathUtilities.js';
+import { CLIOptionsKeys } from './CLIOptions.js';
 //const log = logToStderr
 async function startIfInWorkerThread() {
     if (isMainThread || !parentPort) {
@@ -46,81 +47,122 @@ async function startIfInWorkerThread() {
 }
 export async function start(processArgs) {
     const logger = new Logger();
-    let args;
+    const operationData = {
+        operation: '',
+        operationArgs: [],
+        globalOptions: {},
+        cliOptions: {},
+        operationOptionsLookup: new Map(),
+    };
     try {
         const packageData = await readAndParseJsonFile(resolveToModuleRootDir('package.json'));
         logger.log(chalk.magentaBright(`Echogarden v${packageData.version}\n`));
-        const command = processArgs[0];
-        if (!command || command == 'help') {
-            logger.log(`Supported operations:\n\n${commandHelp.join('\n')}`);
+        const operation = processArgs[0];
+        if (!operation || operation == 'help') {
+            logger.log(`Supported operations:\n\n${help.join('\n')}`);
             process.exit(0);
         }
-        if (command == '--help') {
-            logger.log(`There's no command called '--help'. Did you mean to run 'echogarden help'?`);
-            process.exit(0);
+        if (operation == '--help' || operation == '-h') {
+            logger.log(`There's no operation called '${operation}'. Did you mean to run 'echogarden help'?`);
+            process.exit(1);
         }
-        args = parseCLIArguments(command, processArgs.slice(1));
-        if (!args.options.has('config')) {
+        if (operation.startsWith('-')) {
+            logger.log(`Operation name '${operation}' is invalid. It cannot start with a hyphen.`);
+            process.exit(1);
+        }
+        const { operationArgs, parsedArgumentsLookup } = parseCLIArguments(processArgs.slice(1));
+        if (!parsedArgumentsLookup.has('config')) {
             const defaultConfigFile = `./${appName}.config`;
             const defaultJsonConfigFile = defaultConfigFile + '.json';
             if (existsSync(defaultConfigFile)) {
-                args.options.set('config', defaultConfigFile);
+                parsedArgumentsLookup.set('config', defaultConfigFile);
             }
             else if (existsSync(defaultJsonConfigFile)) {
-                args.options.set('config', defaultJsonConfigFile);
+                parsedArgumentsLookup.set('config', defaultJsonConfigFile);
             }
         }
-        if (args.options.has('config')) {
-            const configFilePath = args.options.get('config');
-            args.options.delete('config');
-            let parsedOptionFile;
+        if (parsedArgumentsLookup.has('config')) {
+            const configFilePath = parsedArgumentsLookup.get('config');
+            parsedArgumentsLookup.delete('config');
+            let parsedConfigFile;
             if (configFilePath.endsWith('.config')) {
-                parsedOptionFile = await parseConfigFile(configFilePath);
+                parsedConfigFile = await parseConfigFile(configFilePath);
             }
             else if (configFilePath.endsWith('.config.json')) {
-                parsedOptionFile = await parseJSONConfigFile(configFilePath);
+                parsedConfigFile = await parseJSONConfigFile(configFilePath);
             }
             else {
                 throw new Error(`Specified config file '${configFilePath}' doesn't have a supported extension. Should be either '.config' or '.config.json'`);
             }
-            let sectionName = args.command;
+            let sectionName = operation;
             if (sectionName.startsWith('speak-')) {
                 sectionName = 'speak';
             }
-            const newOptions = parsedOptionFile.get(sectionName) || new Map();
-            for (const [key, value] of args.options) {
-                newOptions.set(key, value);
+            const globalOptionsLookup = new Map();
+            const cliOptionsLookup = new Map();
+            const operationsOptionsLookup = new Map();
+            if (parsedConfigFile.has('global')) {
+                for (const [key, value] of parsedConfigFile.get('global')) {
+                    globalOptionsLookup.set(key, value);
+                }
+            }
+            if (parsedConfigFile.has('cli')) {
+                for (const [key, value] of parsedConfigFile.get('cli')) {
+                    cliOptionsLookup.set(key, value);
+                }
+            }
+            if (parsedConfigFile.has(sectionName)) {
+                for (const [key, value] of parsedConfigFile.get(sectionName)) {
+                    operationsOptionsLookup.set(key, value);
+                }
+            }
+            const globalOptionsKeys = API.listGlobalOptions();
+            const cliOptionsKeys = CLIOptionsKeys;
+            for (const [key, value] of parsedArgumentsLookup) {
+                if (globalOptionsKeys.includes(key)) {
+                    globalOptionsLookup.set(key, value);
+                }
+                else if (cliOptionsKeys.includes(key)) {
+                    cliOptionsLookup.set(key, value);
+                }
+                else {
+                    operationsOptionsLookup.set(key, value);
+                }
             }
-            args.options = newOptions;
+            operationData.operation = operation;
+            operationData.operationArgs = operationArgs;
+            operationData.globalOptions = await optionsLookupToTypedObject(globalOptionsLookup, 'GlobalOptions');
+            operationData.cliOptions = await optionsLookupToTypedObject(cliOptionsLookup, 'CLIOptions');
+            operationData.operationOptionsLookup = operationsOptionsLookup;
         }
     }
     catch (e) {
         resetActiveLogger();
-        logger.logTitledMessage(`Error`, e.message, chalk.redBright);
+        logger.logTitledMessage(`Error`, e.message, chalk.redBright, 'error');
         process.exit(1);
     }
-    let debugMode = false;
-    if (args.options.has('debug')) {
-        args.options.delete('debug');
-        debugMode = true;
+    for (const key in operationData.globalOptions) {
+        const value = operationData.globalOptions[key];
+        API.setGlobalOption(key, value);
     }
+    const debugMode = operationData.cliOptions.debug || false;
     try {
-        await startWithArgs(args);
+        await startWithArgs(operationData);
     }
     catch (e) {
         resetActiveLogger();
         if (debugMode) {
-            logger.log(e);
+            logger.log(e, 'error');
         }
         else {
-            logger.logTitledMessage(`Error`, e.message, chalk.redBright);
+            logger.logTitledMessage(`Error`, e.message, chalk.redBright, 'error');
         }
         process.exit(1);
     }
     process.exit(0);
 }
 const executableName = `${chalk.cyanBright('echogarden')}`;
-const commandHelp = [
+const help = [
     `${executableName} ${chalk.magentaBright('speak')} text [output files...] [options...]`,
     `    Speak the given text\n`,
     `${executableName} ${chalk.magentaBright('speak-file')} inputFile [output files...] [options...]`,
@@ -160,103 +202,103 @@ const commandHelp = [
     `${executableName} ${chalk.magentaBright('serve')} [options...]`,
     `    Start a server\n`,
     `Options reference: ${chalk.blueBright('https://bit.ly/echogarden-options')}`
-    //`    ${chalk.blueBright('https://github.com/echogarden-project/echogarden/blob/main/docs/Options.md')}`
 ];
-async function startWithArgs(parsedArgs) {
+async function startWithArgs(operationData) {
     const logger = new Logger();
-    switch (parsedArgs.command) {
+    switch (operationData.operation) {
         case 'speak':
         case 'speak-file':
         case 'speak-url':
         case 'speak-wikipedia': {
-            await speak(parsedArgs.command, parsedArgs.commandArgs, parsedArgs.options);
+            await speak(operationData);
             break;
         }
         case 'transcribe': {
-            await transcribe(parsedArgs.commandArgs, parsedArgs.options);
+            await transcribe(operationData);
             break;
         }
         case 'align': {
-            await align(parsedArgs.commandArgs, parsedArgs.options);
+            await align(operationData);
             break;
         }
         case 'translate-speech': {
-            await translateSpeech(parsedArgs.commandArgs, parsedArgs.options);
+            await translateSpeech(operationData);
             break;
         }
         case 'align-translation': {
-            await alignTranslation(parsedArgs.commandArgs, parsedArgs.options);
+            await alignTranslation(operationData);
             break;
         }
         case 'detect-language': {
-            await detectLanguage(parsedArgs.commandArgs, parsedArgs.options, 'auto');
+            await detectLanguage(operationData, 'auto');
             break;
         }
         case 'detect-speech-language': {
-            await detectLanguage(parsedArgs.commandArgs, parsedArgs.options, 'speech');
+            await detectLanguage(operationData, 'speech');
             break;
         }
         case 'detect-text-language': {
-            await detectLanguage(parsedArgs.commandArgs, parsedArgs.options, 'text');
+            await detectLanguage(operationData, 'text');
             break;
         }
         case 'detect-voice-activity': {
-            await detectVoiceActivity(parsedArgs.commandArgs, parsedArgs.options);
+            await detectVoiceActivity(operationData);
             break;
         }
         case 'denoise': {
-            await denoise(parsedArgs.commandArgs, parsedArgs.options);
+            await denoise(operationData);
             break;
         }
         case 'isolate': {
-            await isolate(parsedArgs.commandArgs, parsedArgs.options);
+            await isolate(operationData);
             break;
         }
         case 'list-engines': {
-            await listEngines(parsedArgs.commandArgs, parsedArgs.options);
+            await listEngines(operationData);
             break;
         }
         case 'list-voices': {
-            await listTTSVoices(parsedArgs.commandArgs, parsedArgs.options);
+            await listTTSVoices(operationData);
             break;
         }
         case 'install': {
-            await installPackages(parsedArgs.commandArgs, parsedArgs.options);
+            await installPackages(operationData);
             break;
         }
         case 'uninstall': {
-            await uninstallPackages(parsedArgs.commandArgs, parsedArgs.options);
+            await uninstallPackages(operationData);
             break;
         }
         case 'list-packages': {
-            await listPackages(parsedArgs.commandArgs, parsedArgs.options);
+            await listPackages(operationData);
             break;
         }
         case 'serve': {
-            await serve(parsedArgs.commandArgs, parsedArgs.options);
+            await serve(operationData);
             break;
         }
         default: {
-            logger.logTitledMessage(`Unknown command`, parsedArgs.command, chalk.redBright);
+            logger.logTitledMessage(`Unknown operation`, operationData.operation, chalk.redBright, 'error');
             process.exit(1);
         }
     }
 }
-async function speak(command, commandArgs, cliOptions) {
+async function speak(operationData) {
     const logger = new Logger();
-    const mainArg = commandArgs[0];
-    const outputFilenames = commandArgs.slice(1);
+    const { operationArgs, operation, operationOptionsLookup, cliOptions } = operationData;
+    const mainArg = operationArgs[0];
+    const outputFilenames = operationArgs.slice(1);
     if (mainArg == undefined) {
-        if (command == 'speak') {
+        if (operation == 'speak') {
             throw new Error(`'speak' requires an argument containing the text to speak.`);
         }
-        else if (command == 'speak-file') {
+        else if (operation == 'speak-file') {
             throw new Error(`'speak-file' requires an argument containing the file to speak.`);
         }
-        else if (command == 'speak-url') {
+        else if (operation == 'speak-url') {
             throw new Error(`'speak-url' requires an argument containing the url to speak.`);
         }
-        else if (command == 'speak-wikipedia') {
+        else if (operation == 'speak-wikipedia') {
             throw new Error(`'speak-wikipedia' requires an argument containing the name of the Wikipedia article to speak.`);
         }
         return;
@@ -264,17 +306,17 @@ async function speak(command, commandArgs, cliOptions) {
     const additionalOptionsSchema = new Map();
     additionalOptionsSchema.set('play', { type: 'boolean' });
     additionalOptionsSchema.set('overwrite', { type: 'boolean' });
-    if (!cliOptions.has('play') && !cliOptions.has('no-play')) {
-        cliOptions.set('play', `${outputFilenames.length == 0}`);
+    if (cliOptions.play == null) {
+        cliOptions.play = outputFilenames.length === 0;
     }
-    const options = await cliOptionsMapToOptionsObject(cliOptions, 'SynthesisOptions', additionalOptionsSchema);
-    const allowOverwrite = getWithDefault(options.overwrite, overwriteByDefault);
+    const options = await optionsLookupToTypedObject(operationOptionsLookup, 'SynthesisOptions', additionalOptionsSchema);
+    const allowOverwrite = getWithDefault(cliOptions.overwrite, overwriteByDefault);
     const { includesPlaceholderPattern } = await checkOutputFilenames(outputFilenames, true, true, true);
     let plainText = undefined;
     let textSegments;
     const plainTextParagraphBreaks = options.plainText?.paragraphBreaks || API.defaultSynthesisOptions.plainText.paragraphBreaks;
     const plainTextWhitespace = options.plainText?.whitespace || API.defaultSynthesisOptions.plainText.whitespace;
-    if (command == 'speak') {
+    if (operation == 'speak') {
         if (options.ssml) {
             textSegments = [mainArg];
         }
@@ -283,7 +325,7 @@ async function speak(command, commandArgs, cliOptions) {
         }
         plainText = mainArg;
     }
-    else if (command == 'speak-file') {
+    else if (operation == 'speak-file') {
         const sourceFile = mainArg;
         if (!existsSync(sourceFile)) {
             throw new Error(`The given source file '${sourceFile}' was not found.`);
@@ -313,9 +355,9 @@ async function speak(command, commandArgs, cliOptions) {
             throw new Error(`'speak-file' only supports inputs with extensions 'txt', 'html', 'htm', 'xml', 'ssml', 'srt', 'vtt'`);
         }
     }
-    else if (command == 'speak-url') {
+    else if (operation == 'speak-url') {
         if (options.ssml) {
-            throw new Error(`speak-url doesn't provide SSML inputs`);
+            throw new Error(`speak-url doesn't accept SSML inputs`);
         }
         const url = mainArg;
         if (!url.startsWith('http://') && !url.startsWith('https://')) {
@@ -325,7 +367,7 @@ async function speak(command, commandArgs, cliOptions) {
         const textContent = await fetchDocumentText(url);
         textSegments = splitToParagraphs(textContent, 'single', 'preserve');
     }
-    else if (command == 'speak-wikipedia') {
+    else if (operation == 'speak-wikipedia') {
         if (options.ssml) {
             throw new Error(`speak-wikipedia doesn't provide SSML inputs`);
         }
@@ -336,7 +378,7 @@ async function speak(command, commandArgs, cliOptions) {
         textSegments = await parseWikipediaArticle(mainArg, getShortLanguageCode(options.language));
     }
     else {
-        throw new Error('Invalid command');
+        throw new Error(`Invalid operation specified: '${operation}'`);
     }
     async function onSegment(segmentData) {
         if (includesPlaceholderPattern) {
@@ -344,7 +386,7 @@ async function speak(command, commandArgs, cliOptions) {
         }
         await writeOutputFilesForSegment(outputFilenames, segmentData.index, segmentData.total, segmentData.audio, segmentData.timeline, segmentData.transcript, segmentData.language, allowOverwrite);
         logger.end();
-        if (options.play) {
+        if (cliOptions.play) {
             let gainAmount = -3 - segmentData.peakDecibelsSoFar;
             //gainAmount = Math.min(gainAmount, 0)
             const audioWithAddedGain = applyGainDecibels(segmentData.audio, gainAmount);
@@ -372,24 +414,22 @@ async function speak(command, commandArgs, cliOptions) {
     }
     logger.end();
 }
-async function transcribe(commandArgs, cliOptions) {
+async function transcribe(operationData) {
     const logger = new Logger();
-    const sourceFilename = commandArgs[0];
-    const outputFilenames = commandArgs.slice(1);
+    const { operationArgs, operationOptionsLookup, cliOptions } = operationData;
+    const sourceFilename = operationArgs[0];
+    const outputFilenames = operationArgs.slice(1);
     if (sourceFilename == undefined) {
         throw new Error(`'transcribe' requires an argument containing the source file name.`);
     }
     if (!existsSync(sourceFilename)) {
         throw new Error(`The given source audio file '${sourceFilename}' was not found.`);
     }
-    const additionalOptionsSchema = new Map();
-    additionalOptionsSchema.set('play', { type: 'boolean' });
-    additionalOptionsSchema.set('overwrite', { type: 'boolean' });
-    if (!cliOptions.has('play') && !cliOptions.has('no-play')) {
-        cliOptions.set('play', `${outputFilenames.length == 0}`);
+    if (cliOptions.play == null) {
+        cliOptions.play = outputFilenames.length === 0;
     }
-    const options = await cliOptionsMapToOptionsObject(cliOptions, 'RecognitionOptions', additionalOptionsSchema);
-    const allowOverwrite = getWithDefault(options.overwrite, overwriteByDefault);
+    const options = await optionsLookupToTypedObject(operationOptionsLookup, 'RecognitionOptions');
+    const allowOverwrite = getWithDefault(cliOptions.overwrite, overwriteByDefault);
     const { includesPlaceholderPattern } = await checkOutputFilenames(outputFilenames, true, true, true);
     const { transcript, timeline, wordTimeline, language, inputRawAudio, isolatedRawAudio, backgroundRawAudio } = await API.recognize(sourceFilename, options);
     if (outputFilenames.length > 0) {
@@ -405,7 +445,7 @@ async function transcribe(commandArgs, cliOptions) {
         await writeSourceSeparationOutputIfNeeded(outputFilename, isolatedRawAudio, backgroundRawAudio, allowOverwrite, true);
     }
     logger.end();
-    if (options.play) {
+    if (cliOptions.play) {
         let audioToPlay;
         if (isolatedRawAudio) {
             audioToPlay = isolatedRawAudio;
@@ -417,17 +457,18 @@ async function transcribe(commandArgs, cliOptions) {
         await playAudioWithWordTimeline(normalizedAudioToPlay, wordTimeline, transcript);
     }
 }
-async function align(commandArgs, cliOptions) {
+async function align(operationData) {
     const logger = new Logger();
-    const audioFilename = commandArgs[0];
-    const outputFilenames = commandArgs.slice(2);
+    const { operationArgs, operationOptionsLookup, cliOptions } = operationData;
+    const audioFilename = operationArgs[0];
+    const outputFilenames = operationArgs.slice(2);
     if (audioFilename == undefined) {
         throw new Error(`align requires an argument containing the audio file path.`);
     }
     if (!existsSync(audioFilename)) {
         throw new Error(`The given source file '${audioFilename}' was not found.`);
     }
-    const alignmentReferenceFile = commandArgs[1];
+    const alignmentReferenceFile = operationArgs[1];
     if (alignmentReferenceFile == undefined) {
         throw new Error(`align requires a second argument containing the alignment reference file path.`);
     }
@@ -449,14 +490,11 @@ async function align(commandArgs, cliOptions) {
     else {
         throw new Error(`align only supports reference files with extensions 'txt', 'html', 'htm', 'srt' or 'vtt'`);
     }
-    const additionalOptionsSchema = new Map();
-    additionalOptionsSchema.set('play', { type: 'boolean' });
-    additionalOptionsSchema.set('overwrite', { type: 'boolean' });
-    if (!cliOptions.has('play') && !cliOptions.has('no-play')) {
-        cliOptions.set('play', `${outputFilenames.length == 0}`);
+    if (cliOptions.play == null) {
+        cliOptions.play = outputFilenames.length === 0;
     }
-    const options = await cliOptionsMapToOptionsObject(cliOptions, 'AlignmentOptions', additionalOptionsSchema);
-    const allowOverwrite = getWithDefault(options.overwrite, overwriteByDefault);
+    const options = await optionsLookupToTypedObject(operationOptionsLookup, 'AlignmentOptions');
+    const allowOverwrite = getWithDefault(cliOptions.overwrite, overwriteByDefault);
     const { includesPlaceholderPattern } = await checkOutputFilenames(outputFilenames, true, true, true);
     const { timeline, wordTimeline, transcript, language, inputRawAudio, isolatedRawAudio, backgroundRawAudio } = await API.align(audioFilename, text, options);
     if (outputFilenames.length > 0) {
@@ -480,7 +518,7 @@ async function align(commandArgs, cliOptions) {
         await writeSourceSeparationOutputIfNeeded(outputFilename, isolatedRawAudio, backgroundRawAudio, allowOverwrite, true);
     }
     logger.end();
-    if (options.play) {
+    if (cliOptions.play) {
         let audioToPlay;
         if (isolatedRawAudio) {
             audioToPlay = isolatedRawAudio;
@@ -492,17 +530,18 @@ async function align(commandArgs, cliOptions) {
         await playAudioWithWordTimeline(normalizedAudioToPlay, wordTimeline, transcript);
     }
 }
-async function alignTranslation(commandArgs, cliOptions) {
+async function alignTranslation(operationData) {
     const logger = new Logger();
-    const audioFilename = commandArgs[0];
-    const outputFilenames = commandArgs.slice(2);
+    const { operationArgs, operationOptionsLookup, cliOptions } = operationData;
+    const audioFilename = operationArgs[0];
+    const outputFilenames = operationArgs.slice(2);
     if (audioFilename == undefined) {
         throw new Error(`align-translation requires an argument containing the audio file path.`);
     }
     if (!existsSync(audioFilename)) {
         throw new Error(`The given source file '${audioFilename}' was not found.`);
     }
-    const alignmentReferenceFile = commandArgs[1];
+    const alignmentReferenceFile = operationArgs[1];
     if (alignmentReferenceFile == undefined) {
         throw new Error(`align-translation requires a second argument containing the translated reference file path.`);
     }
@@ -524,14 +563,11 @@ async function alignTranslation(commandArgs, cliOptions) {
     else {
         throw new Error(`align only supports reference files with extensions 'txt', 'html', 'htm', 'srt' or 'vtt'`);
     }
-    const additionalOptionsSchema = new Map();
-    additionalOptionsSchema.set('play', { type: 'boolean' });
-    additionalOptionsSchema.set('overwrite', { type: 'boolean' });
-    if (!cliOptions.has('play') && !cliOptions.has('no-play')) {
-        cliOptions.set('play', `${outputFilenames.length == 0}`);
+    if (cliOptions.play == null) {
+        cliOptions.play = outputFilenames.length === 0;
     }
-    const options = await cliOptionsMapToOptionsObject(cliOptions, 'TranslationAlignmentOptions', additionalOptionsSchema);
-    const allowOverwrite = getWithDefault(options.overwrite, overwriteByDefault);
+    const options = await optionsLookupToTypedObject(operationOptionsLookup, 'TranslationAlignmentOptions');
+    const allowOverwrite = getWithDefault(cliOptions.overwrite, overwriteByDefault);
     const { includesPlaceholderPattern } = await checkOutputFilenames(outputFilenames, true, true, true);
     const { timeline, wordTimeline, transcript, language, inputRawAudio, isolatedRawAudio, backgroundRawAudio } = await API.alignTranslation(audioFilename, text, options);
     if (outputFilenames.length > 0) {
@@ -555,7 +591,7 @@ async function alignTranslation(commandArgs, cliOptions) {
         await writeSourceSeparationOutputIfNeeded(outputFilename, isolatedRawAudio, backgroundRawAudio, allowOverwrite, true);
     }
     logger.end();
-    if (options.play) {
+    if (cliOptions.play) {
         let audioToPlay;
         if (isolatedRawAudio) {
             audioToPlay = isolatedRawAudio;
@@ -567,24 +603,22 @@ async function alignTranslation(commandArgs, cliOptions) {
         await playAudioWithWordTimeline(normalizedAudioToPlay, wordTimeline, transcript);
     }
 }
-async function translateSpeech(commandArgs, cliOptions) {
+async function translateSpeech(operationData) {
     const logger = new Logger();
-    const inputFilename = commandArgs[0];
-    const outputFilenames = commandArgs.slice(1);
+    const { operationArgs, operationOptionsLookup, cliOptions } = operationData;
+    const inputFilename = operationArgs[0];
+    const outputFilenames = operationArgs.slice(1);
     if (inputFilename == undefined) {
         throw new Error(`translate-speech requires an argument containing the input file path.`);
     }
     if (!existsSync(inputFilename)) {
         throw new Error(`The given input file '${inputFilename}' was not found.`);
     }
-    const additionalOptionsSchema = new Map();
-    additionalOptionsSchema.set('play', { type: 'boolean' });
-    additionalOptionsSchema.set('overwrite', { type: 'boolean' });
-    if (!cliOptions.has('play') && !cliOptions.has('no-play')) {
-        cliOptions.set('play', `${outputFilenames.length == 0}`);
+    if (cliOptions.play == null) {
+        cliOptions.play = outputFilenames.length === 0;
     }
-    const options = await cliOptionsMapToOptionsObject(cliOptions, 'SpeechTranslationOptions', additionalOptionsSchema);
-    const allowOverwrite = getWithDefault(options.overwrite, overwriteByDefault);
+    const options = await optionsLookupToTypedObject(operationOptionsLookup, 'SpeechTranslationOptions');
+    const allowOverwrite = getWithDefault(cliOptions.overwrite, overwriteByDefault);
     await checkOutputFilenames(outputFilenames, true, true, true);
     const { transcript, timeline, wordTimeline, sourceLanguage, targetLanguage, inputRawAudio, isolatedRawAudio, backgroundRawAudio } = await API.translateSpeech(inputFilename, options);
     if (outputFilenames.length > 0) {
@@ -600,7 +634,7 @@ async function translateSpeech(commandArgs, cliOptions) {
         await writeSourceSeparationOutputIfNeeded(outputFilename, isolatedRawAudio, backgroundRawAudio, allowOverwrite, true);
     }
     logger.end();
-    if (options.play) {
+    if (cliOptions.play) {
         let audioToPlay;
         if (isolatedRawAudio) {
             audioToPlay = isolatedRawAudio;
@@ -632,15 +666,14 @@ async function translateSpeech(commandArgs, cliOptions) {
         await playAudioWithWordTimeline(normalizedAudioToPlay, timelineToPlay, transcriptToPlay);
     }
 }
-async function detectLanguage(commandArgs, cliOptions, mode) {
+async function detectLanguage(operationData, mode) {
     const logger = new Logger();
-    const inputFilePath = commandArgs[0];
-    const outputFilenames = commandArgs.slice(1);
+    const { operationArgs, operationOptionsLookup, cliOptions } = operationData;
+    const inputFilePath = operationArgs[0];
+    const outputFilenames = operationArgs.slice(1);
     if (!existsSync(inputFilePath)) {
         throw new Error(`The given input file '${inputFilePath}' was not found.`);
     }
-    const additionalOptionsSchema = new Map();
-    additionalOptionsSchema.set('overwrite', { type: 'boolean' });
     const inputFileExtension = getLowercaseFileExtension(inputFilePath);
     const supportedInputTextFormats = ['txt', 'srt', 'vtt'];
     let results;
@@ -652,8 +685,8 @@ async function detectLanguage(commandArgs, cliOptions, mode) {
         if (!supportedInputTextFormats.includes(inputFileExtension)) {
             throw new Error(`'detect-text-language' doesn't support input file extension '${inputFileExtension}'`);
         }
-        const options = await cliOptionsMapToOptionsObject(cliOptions, 'TextLanguageDetectionOptions', additionalOptionsSchema);
-        allowOverwrite = getWithDefault(options.overwrite, overwriteByDefault);
+        const options = await optionsLookupToTypedObject(operationOptionsLookup, 'TextLanguageDetectionOptions');
+        allowOverwrite = getWithDefault(cliOptions.overwrite, overwriteByDefault);
         await checkOutputFilenames(outputFilenames, false, true, false);
         let text = await readFile(inputFilePath, { encoding: 'utf-8' });
         if (inputFileExtension == 'srt' || inputFileExtension == 'vtt') {
@@ -666,8 +699,8 @@ async function detectLanguage(commandArgs, cliOptions, mode) {
         if (inputFilePath == undefined) {
             throw new Error(`detect-speech-language requires an argument containing the input audio file path.`);
         }
-        const options = await cliOptionsMapToOptionsObject(cliOptions, 'SpeechLanguageDetectionOptions', additionalOptionsSchema);
-        allowOverwrite = getWithDefault(options.overwrite, overwriteByDefault);
+        const options = await optionsLookupToTypedObject(operationOptionsLookup, 'SpeechLanguageDetectionOptions');
+        allowOverwrite = getWithDefault(cliOptions.overwrite, overwriteByDefault);
         await checkOutputFilenames(outputFilenames, false, true, false);
         const { detectedLanguage, detectedLanguageProbabilities } = await API.detectSpeechLanguage(inputFilePath, options);
         results = detectedLanguageProbabilities;
@@ -682,29 +715,27 @@ async function detectLanguage(commandArgs, cliOptions, mode) {
     }
     else {
         const resultsAsText = results.slice(0, 10).map(result => `${formatLanguageCodeWithName(result.language)}: ${result.probability.toFixed(5)}`).join('\n');
-        logger.log('');
-        logger.log(resultsAsText);
+        logger.log('', 'output');
+        logger.log(resultsAsText, 'output');
     }
     logger.end();
 }
-async function detectVoiceActivity(commandArgs, cliOptions) {
+async function detectVoiceActivity(operationData) {
     const logger = new Logger();
-    const audioFilename = commandArgs[0];
-    const outputFilenames = commandArgs.slice(1);
+    const { operationArgs, operationOptionsLookup, cliOptions } = operationData;
+    const audioFilename = operationArgs[0];
+    const outputFilenames = operationArgs.slice(1);
     if (audioFilename == undefined) {
         throw new Error(`detect-voice-activity requires an argument containing the audio file path.`);
     }
     if (!existsSync(audioFilename)) {
         throw new Error(`The given source audio file '${audioFilename}' was not found.`);
     }
-    const additionalOptionsSchema = new Map();
-    additionalOptionsSchema.set('play', { type: 'boolean' });
-    additionalOptionsSchema.set('overwrite', { type: 'boolean' });
-    if (!cliOptions.has('play') && !cliOptions.has('no-play')) {
-        cliOptions.set('play', `${outputFilenames.length == 0}`);
+    if (cliOptions.play == null) {
+        cliOptions.play = outputFilenames.length === 0;
     }
-    const options = await cliOptionsMapToOptionsObject(cliOptions, 'VADOptions', additionalOptionsSchema);
-    const allowOverwrite = getWithDefault(options.overwrite, overwriteByDefault);
+    const options = await optionsLookupToTypedObject(operationOptionsLookup, 'VADOptions');
+    const allowOverwrite = getWithDefault(cliOptions.overwrite, overwriteByDefault);
     await checkOutputFilenames(outputFilenames, true, true, true);
     let { timeline, verboseTimeline, inputRawAudio, croppedRawAudio } = await API.detectVoiceActivity(audioFilename, options);
     if (outputFilenames.length > 0) {
@@ -726,7 +757,7 @@ async function detectVoiceActivity(commandArgs, cliOptions) {
         }
     }
     logger.end();
-    if (options.play) {
+    if (cliOptions.play) {
         const normalizedAudio = normalizeAudioLevel(inputRawAudio);
         const timelineToPlay = verboseTimeline.map(entry => {
             return { ...entry, type: 'word' };
@@ -734,24 +765,22 @@ async function detectVoiceActivity(commandArgs, cliOptions) {
         await playAudioWithWordTimeline(normalizedAudio, timelineToPlay);
     }
 }
-async function denoise(commandArgs, cliOptions) {
+async function denoise(operationData) {
     const logger = new Logger();
-    const audioFilename = commandArgs[0];
-    const outputFilenames = commandArgs.slice(1);
+    const { operationArgs, operationOptionsLookup, cliOptions } = operationData;
+    const audioFilename = operationArgs[0];
+    const outputFilenames = operationArgs.slice(1);
     if (audioFilename == undefined) {
         throw new Error(`'denoise' requires an argument containing the audio file path.`);
     }
     if (!existsSync(audioFilename)) {
         throw new Error(`The given source audio file '${audioFilename}' was not found.`);
     }
-    const additionalOptionsSchema = new Map();
-    additionalOptionsSchema.set('play', { type: 'boolean' });
-    additionalOptionsSchema.set('overwrite', { type: 'boolean' });
-    if (!cliOptions.has('play') && !cliOptions.has('no-play')) {
-        cliOptions.set('play', `${outputFilenames.length == 0}`);
+    if (cliOptions.play == null) {
+        cliOptions.play = outputFilenames.length === 0;
     }
-    const options = await cliOptionsMapToOptionsObject(cliOptions, 'DenoisingOptions', additionalOptionsSchema);
-    const allowOverwrite = getWithDefault(options.overwrite, overwriteByDefault);
+    const options = await optionsLookupToTypedObject(operationOptionsLookup, 'DenoisingOptions');
+    const allowOverwrite = getWithDefault(cliOptions.overwrite, overwriteByDefault);
     await checkOutputFilenames(outputFilenames, true, false, false);
     const { denoisedAudio } = await API.denoise(audioFilename, options);
     if (outputFilenames.length > 0) {
@@ -762,28 +791,26 @@ async function denoise(commandArgs, cliOptions) {
         await fileSaver(denoisedAudio, [], '');
     }
     logger.end();
-    if (options.play) {
+    if (cliOptions.play) {
         await playAudioSamples(denoisedAudio);
     }
 }
-async function isolate(commandArgs, cliOptions) {
+async function isolate(operationData) {
     const logger = new Logger();
-    const audioFilename = commandArgs[0];
-    const outputFilenames = commandArgs.slice(1);
+    const { operationArgs, operationOptionsLookup, cliOptions } = operationData;
+    const audioFilename = operationArgs[0];
+    const outputFilenames = operationArgs.slice(1);
     if (audioFilename == undefined) {
         throw new Error(`'isolate' requires an argument containing the audio file path.`);
     }
     if (!existsSync(audioFilename)) {
         throw new Error(`The given source audio file '${audioFilename}' was not found.`);
     }
-    const additionalOptionsSchema = new Map();
-    additionalOptionsSchema.set('play', { type: 'boolean' });
-    additionalOptionsSchema.set('overwrite', { type: 'boolean' });
-    if (!cliOptions.has('play') && !cliOptions.has('no-play')) {
-        cliOptions.set('play', `${outputFilenames.length == 0}`);
+    if (cliOptions.play == null) {
+        cliOptions.play = outputFilenames.length === 0;
     }
-    const options = await cliOptionsMapToOptionsObject(cliOptions, 'SourceSeparationOptions', additionalOptionsSchema);
-    const allowOverwrite = getWithDefault(options.overwrite, overwriteByDefault);
+    const options = await optionsLookupToTypedObject(operationOptionsLookup, 'SourceSeparationOptions');
+    const allowOverwrite = getWithDefault(cliOptions.overwrite, overwriteByDefault);
     await checkOutputFilenames(outputFilenames, true, false, false);
     const { inputRawAudio, isolatedRawAudio, backgroundRawAudio } = await API.isolate(audioFilename, options);
     if (outputFilenames.length > 0) {
@@ -793,15 +820,16 @@ async function isolate(commandArgs, cliOptions) {
         await writeSourceSeparationOutputIfNeeded(outputFilename, isolatedRawAudio, backgroundRawAudio, allowOverwrite, false);
     }
     logger.end();
-    if (options.play) {
+    if (cliOptions.play) {
         await playAudioSamples(isolatedRawAudio);
     }
 }
-async function listEngines(commandArgs, cliOptions) {
+async function listEngines(operationData) {
     const logger = new Logger();
-    const targetOperation = commandArgs[0];
+    const { operationArgs } = operationData;
+    const targetOperation = operationArgs[0];
     if (!targetOperation) {
-        throw new Error(`The 'list-engines' command requires an argument specifying the operation to list engines for, like 'echogarden list-engines transcribe'.`);
+        throw new Error(`The 'list-engines' operation requires an argument specifying the operation to list engines for, like 'echogarden list-engines transcribe'.`);
     }
     let engines;
     switch (targetOperation) {
@@ -867,19 +895,20 @@ async function listEngines(commandArgs, cliOptions) {
         }
     }
     for (const [index, engine] of engines.entries()) {
-        logger.logTitledMessage('Identifier', chalk.magentaBright(engine.id));
-        logger.logTitledMessage('Name', engine.name);
-        logger.logTitledMessage('Description', engine.description);
-        logger.logTitledMessage('Type', engine.type);
+        logger.logTitledMessage('Identifier', chalk.magentaBright(engine.id), undefined, 'output');
+        logger.logTitledMessage('Name', engine.name, undefined, 'output');
+        logger.logTitledMessage('Description', engine.description, undefined, 'output');
+        logger.logTitledMessage('Type', engine.type, undefined, 'output');
         if (index < engines.length - 1) {
-            logger.log('');
+            logger.log('', 'output');
         }
     }
 }
-async function listTTSVoices(commandArgs, cliOptions) {
+async function listTTSVoices(operationData) {
     const logger = new Logger();
-    const targetEngine = commandArgs[0];
-    const outputFilenames = commandArgs.slice(1);
+    const { operationArgs, operationOptionsLookup, cliOptions } = operationData;
+    const targetEngine = operationArgs[0];
+    const outputFilenames = operationArgs.slice(1);
     if (!targetEngine) {
         const optionsSchema = await getOptionsSchema();
         const { enum: ttsEnginesEnum } = getOptionTypeFromSchema(['VoiceListRequestOptions', 'engine'], optionsSchema);
@@ -887,9 +916,9 @@ async function listTTSVoices(commandArgs, cliOptions) {
     }
     const additionalOptionsSchema = new Map();
     additionalOptionsSchema.set('overwrite', { type: 'boolean' });
-    cliOptions.set('engine', targetEngine);
-    const options = await cliOptionsMapToOptionsObject(cliOptions, 'VoiceListRequestOptions', additionalOptionsSchema);
-    const allowOverwrite = getWithDefault(options.overwrite, overwriteByDefault);
+    operationOptionsLookup.set('engine', targetEngine);
+    const options = await optionsLookupToTypedObject(operationOptionsLookup, 'VoiceListRequestOptions');
+    const allowOverwrite = getWithDefault(cliOptions.overwrite, overwriteByDefault);
     await checkOutputFilenames(outputFilenames, false, true, false);
     const { voiceList } = await API.requestVoiceList(options);
     const voiceListText = voiceList.map(entry => {
@@ -913,56 +942,58 @@ async function listTTSVoices(commandArgs, cliOptions) {
         }
     }
     else {
-        logger.log(voiceListText);
+        logger.log(voiceListText, 'output');
     }
     logger.end();
 }
-async function installPackages(commandArgs, cliOptions) {
+async function installPackages(operationData) {
     const logger = new Logger();
-    if (commandArgs.length == 0) {
+    const { operationArgs } = operationData;
+    if (operationArgs.length == 0) {
         throw new Error('No package names specified');
     }
     const failedPackageNames = [];
-    for (const packageName of commandArgs) {
+    for (const packageName of operationArgs) {
         try {
             await loadPackage(packageName);
         }
         catch (e) {
             resetActiveLogger();
-            logger.log(`Failed installing package ${packageName}: ${e}`);
+            logger.logTitledMessage(`Failed installing package ${packageName}`, e, chalk.redBright, 'error');
             failedPackageNames.push(packageName);
         }
     }
     if (failedPackageNames.length > 0) {
         if (failedPackageNames.length == 1) {
-            logger.log(`The package ${failedPackageNames[0]} failed to install`);
+            logger.log(`The package ${failedPackageNames[0]} failed to install`, 'error');
         }
         else {
-            logger.log(`The packages ${failedPackageNames.join(', ')} failed to install`);
+            logger.log(`The packages ${failedPackageNames.join(', ')} failed to install`, 'error');
         }
     }
 }
-async function uninstallPackages(commandArgs, cliOptions) {
+async function uninstallPackages(operationData) {
     const logger = new Logger();
-    if (commandArgs.length == 0) {
+    const { operationArgs } = operationData;
+    if (operationArgs.length == 0) {
         throw new Error('No package names specified');
     }
     const failedPackageNames = [];
-    for (const packageName of commandArgs) {
+    for (const packageName of operationArgs) {
         try {
             await removePackage(packageName);
         }
         catch (e) {
             resetActiveLogger();
-            logger.log(`Failed uninstalling package ${packageName}: ${e}`);
+            logger.logTitledMessage(`Failed uninstalling package ${packageName}`, e, chalk.redBright, 'error');
             failedPackageNames.push(packageName);
         }
     }
     if (failedPackageNames.length > 0) {
-        logger.log(`The packages ${failedPackageNames.join(', ')} failed to uninstall`);
+        logger.log(`The packages ${failedPackageNames.join(', ')} failed to uninstall`, 'error');
     }
 }
-async function listPackages(commandArgs, cliOptions) {
+async function listPackages(operationData) {
     const logger = new Logger();
     const packagesDir = await ensureAndGetPackagesDir();
     const installedPackageNames = await readdir(packagesDir);
@@ -981,11 +1012,13 @@ async function listPackages(commandArgs, cliOptions) {
         }
     });
     installedPackageNamesFormatted.sort();
-    logger.log(`Total of ${installedPackageNamesFormatted.length} packages installed in '${packagesDir}'\n`);
+    logger.log(`Total of ${installedPackageNamesFormatted.length} packages installed in '${packagesDir}'`);
+    logger.log(``);
     logger.log(installedPackageNamesFormatted.join('\n'));
 }
-async function serve(commandArgs, cliOptions) {
-    const options = await cliOptionsMapToOptionsObject(cliOptions, 'ServerOptions');
+async function serve(operationData) {
+    const { operationOptionsLookup } = operationData;
+    const options = await optionsLookupToTypedObject(operationOptionsLookup, 'ServerOptions');
     async function onServerStarted(serverOptions) {
         // Run a test routine (early development)
         //await runClientWebSocketTest(serverOptions.port!, serverOptions.secure!)
@@ -1009,7 +1042,7 @@ async function writeSourceSeparationOutputIfNeeded(outputFilename, isolatedRawAu
         }
     }
 }
-async function cliOptionsMapToOptionsObject(cliOptionsMap, optionsRoot, additionalOptionsSchema) {
+async function optionsLookupToTypedObject(cliOptionsMap, optionsRoot, additionalOptionsSchema) {
     const optionsSchema = await getOptionsSchema();
     const resultingObj = {};
     function setValueAtPath(path, value) {