@unito/integration-sdk 2.3.2 → 2.3.4

package/dist/src/index.cjs

@@ -3,6 +3,7 @@
 var integrationApi = require('@unito/integration-api');
 var cachette = require('cachette');
 var crypto = require('crypto');
+var util = require('util');
 var express = require('express');
 var busboy = require('busboy');
 var https = require('https');
@@ -161,7 +162,12 @@ class Logger {
             status: logLevel,
         };
         if (process.env.NODE_ENV === 'development') {
-            console[logLevel](JSON.stringify(processedLogs, null, 2));
+            const coloredMessage = Logger.colorize(message, processedLogs, logLevel);
+            const metadata = {
+                date: new Date(processedLogs.date).toISOString(),
+                ...processedMetadata,
+            };
+            console[logLevel](`${coloredMessage} ${JSON.stringify(metadata, null, 2)}`);
         }
         else {
             console[logLevel](JSON.stringify(processedLogs));
@@ -170,7 +176,16 @@ class Logger {
     static snakifyKeys(value) {
         const result = {};
         for (const key in value) {
-            const deepValue = typeof value[key] === 'object' ? this.snakifyKeys(value[key]) : value[key];
+            let deepValue;
+            if (Array.isArray(value[key])) {
+                deepValue = value[key].map(item => this.snakifyKeys(item));
+            }
+            else if (typeof value[key] === 'object' && value[key] !== null) {
+                deepValue = this.snakifyKeys(value[key]);
+            }
+            else {
+                deepValue = value[key];
+            }
             const snakifiedKey = key.replace(/[\w](?<!_)([A-Z])/g, k => `${k[0]}_${k[1]}`).toLowerCase();
             result[snakifiedKey] = deepValue;
         }
@@ -183,7 +198,10 @@ class Logger {
                 prunedMetadata[key] = '[REDACTED]';
                 (topLevelMeta ?? prunedMetadata).has_sensitive_attribute = true;
             }
-            else if (typeof metadata[key] === 'object') {
+            else if (Array.isArray(metadata[key])) {
+                prunedMetadata[key] = metadata[key].map(value => Logger.pruneSensitiveMetadata(value, topLevelMeta ?? prunedMetadata));
+            }
+            else if (typeof metadata[key] === 'object' && metadata[key] !== null) {
                 prunedMetadata[key] = Logger.pruneSensitiveMetadata(metadata[key], topLevelMeta ?? prunedMetadata);
             }
             else {
@@ -192,6 +210,56 @@ class Logger {
         }
         return prunedMetadata;
     }
+    /**
+     * Colorizes the log message based on the log level and status codes.
+     * @param message The message to colorize.
+     * @param metadata The metadata associated with the log.
+     * @param logLevel The log level of the message.
+     * @returns The colorized output string.
+     */
+    static colorize(message, metadata, logLevel) {
+        if (!process.stdout.isTTY) {
+            return message;
+        }
+        const logOutput = `${logLevel}: ${message}`;
+        // Extract status code from logs
+        let statusCode;
+        if (metadata.http && typeof metadata.http === 'object' && !Array.isArray(metadata.http)) {
+            const statusCodeValue = metadata.http.status_code;
+            if (typeof statusCodeValue === 'number') {
+                statusCode = statusCodeValue;
+            }
+            else if (typeof statusCodeValue === 'string') {
+                statusCode = parseInt(statusCodeValue, 10);
+            }
+        }
+        // Color based on status code first
+        if (statusCode) {
+            if (statusCode >= 400) {
+                return util.styleText('red', logOutput);
+            }
+            else if (statusCode >= 300) {
+                return util.styleText('yellow', logOutput);
+            }
+            else if (statusCode >= 200) {
+                return util.styleText('green', logOutput);
+            }
+        }
+        // Fall back to log level if no status code found
+        switch (logLevel) {
+            case LogLevel.ERROR:
+                return util.styleText('red', logOutput);
+            case LogLevel.WARN:
+                return util.styleText('yellow', logOutput);
+            case LogLevel.INFO:
+            case LogLevel.LOG:
+                return util.styleText('green', logOutput);
+            case LogLevel.DEBUG:
+                return util.styleText('cyan', logOutput);
+            default:
+                return logOutput;
+        }
+    }
 }
 const NULL_LOGGER = new Logger({}, true);
 

package/dist/src/resources/logger.d.ts

@@ -1,6 +1,6 @@
 type PrimitiveValue = undefined | null | string | string[] | number | number[] | boolean | boolean[];
 type Value = {
-    [key: string]: PrimitiveValue | Value;
+    [key: string]: PrimitiveValue | Value | PrimitiveValue[] | Value[];
 };
 export type Metadata = Value & {
     message?: never;
@@ -68,6 +68,14 @@ export default class Logger {
     private send;
     private static snakifyKeys;
     private static pruneSensitiveMetadata;
+    /**
+     * Colorizes the log message based on the log level and status codes.
+     * @param message The message to colorize.
+     * @param metadata The metadata associated with the log.
+     * @param logLevel The log level of the message.
+     * @returns The colorized output string.
+     */
+    private static colorize;
 }
 export declare const NULL_LOGGER: Logger;
 export {};

package/dist/src/resources/logger.js

@@ -1,3 +1,4 @@
+import { styleText } from 'util';
 var LogLevel;
 (function (LogLevel) {
     LogLevel["ERROR"] = "error";
@@ -133,7 +134,12 @@ export default class Logger {
             status: logLevel,
         };
         if (process.env.NODE_ENV === 'development') {
-            console[logLevel](JSON.stringify(processedLogs, null, 2));
+            const coloredMessage = Logger.colorize(message, processedLogs, logLevel);
+            const metadata = {
+                date: new Date(processedLogs.date).toISOString(),
+                ...processedMetadata,
+            };
+            console[logLevel](`${coloredMessage} ${JSON.stringify(metadata, null, 2)}`);
         }
         else {
             console[logLevel](JSON.stringify(processedLogs));
@@ -142,7 +148,16 @@ export default class Logger {
     static snakifyKeys(value) {
         const result = {};
         for (const key in value) {
-            const deepValue = typeof value[key] === 'object' ? this.snakifyKeys(value[key]) : value[key];
+            let deepValue;
+            if (Array.isArray(value[key])) {
+                deepValue = value[key].map(item => this.snakifyKeys(item));
+            }
+            else if (typeof value[key] === 'object' && value[key] !== null) {
+                deepValue = this.snakifyKeys(value[key]);
+            }
+            else {
+                deepValue = value[key];
+            }
             const snakifiedKey = key.replace(/[\w](?<!_)([A-Z])/g, k => `${k[0]}_${k[1]}`).toLowerCase();
             result[snakifiedKey] = deepValue;
         }
@@ -155,7 +170,10 @@ export default class Logger {
                 prunedMetadata[key] = '[REDACTED]';
                 (topLevelMeta ?? prunedMetadata).has_sensitive_attribute = true;
             }
-            else if (typeof metadata[key] === 'object') {
+            else if (Array.isArray(metadata[key])) {
+                prunedMetadata[key] = metadata[key].map(value => Logger.pruneSensitiveMetadata(value, topLevelMeta ?? prunedMetadata));
+            }
+            else if (typeof metadata[key] === 'object' && metadata[key] !== null) {
                 prunedMetadata[key] = Logger.pruneSensitiveMetadata(metadata[key], topLevelMeta ?? prunedMetadata);
             }
             else {
@@ -164,5 +182,55 @@ export default class Logger {
         }
         return prunedMetadata;
     }
+    /**
+     * Colorizes the log message based on the log level and status codes.
+     * @param message The message to colorize.
+     * @param metadata The metadata associated with the log.
+     * @param logLevel The log level of the message.
+     * @returns The colorized output string.
+     */
+    static colorize(message, metadata, logLevel) {
+        if (!process.stdout.isTTY) {
+            return message;
+        }
+        const logOutput = `${logLevel}: ${message}`;
+        // Extract status code from logs
+        let statusCode;
+        if (metadata.http && typeof metadata.http === 'object' && !Array.isArray(metadata.http)) {
+            const statusCodeValue = metadata.http.status_code;
+            if (typeof statusCodeValue === 'number') {
+                statusCode = statusCodeValue;
+            }
+            else if (typeof statusCodeValue === 'string') {
+                statusCode = parseInt(statusCodeValue, 10);
+            }
+        }
+        // Color based on status code first
+        if (statusCode) {
+            if (statusCode >= 400) {
+                return styleText('red', logOutput);
+            }
+            else if (statusCode >= 300) {
+                return styleText('yellow', logOutput);
+            }
+            else if (statusCode >= 200) {
+                return styleText('green', logOutput);
+            }
+        }
+        // Fall back to log level if no status code found
+        switch (logLevel) {
+            case LogLevel.ERROR:
+                return styleText('red', logOutput);
+            case LogLevel.WARN:
+                return styleText('yellow', logOutput);
+            case LogLevel.INFO:
+            case LogLevel.LOG:
+                return styleText('green', logOutput);
+            case LogLevel.DEBUG:
+                return styleText('cyan', logOutput);
+            default:
+                return logOutput;
+        }
+    }
 }
 export const NULL_LOGGER = new Logger({}, true);

package/dist/test/resources/logger.test.js

@@ -106,7 +106,14 @@ describe('Logger', () => {
     it('snakify keys of Message and Metadata', testContext => {
         const logSpy = testContext.mock.method(global.console, 'log', () => { });
         assert.strictEqual(logSpy.mock.calls.length, 0);
-        const metadata = { correlationId: '123456789', http: { method: 'GET', statusCode: 200 } };
+        const metadata = {
+            correlationId: '123456789',
+            http: { method: 'GET', statusCode: 200 },
+            links: [
+                { id: 1, organizationId: 'a' },
+                { id: 2, organizationId: 'b' },
+            ],
+        };
         const logger = new Logger(metadata);
         logger.log('test', { errorContext: { errorCode: 200, errorMessage: 'Page Not Found' } });
         assert.strictEqual(logSpy.mock.calls.length, 1);
@@ -117,6 +124,10 @@ describe('Logger', () => {
         assert.equal(actual['status'], 'log');
         assert.deepEqual(actual['http'], { method: 'GET', status_code: 200 });
         assert.deepEqual(actual['error_context'], { error_code: 200, error_message: 'Page Not Found' });
+        assert.deepEqual(actual['links'], [
+            { id: 1, organization_id: 'a' },
+            { id: 2, organization_id: 'b' },
+        ]);
     });
     it('prunes sensitive Metadata', testContext => {
         const logSpy = testContext.mock.method(global.console, 'log', () => { });
@@ -126,6 +137,10 @@ describe('Logger', () => {
             http: { method: 'GET', statusCode: 200, jwt: 'deepSecret' },
             user: { contact: { email: 'deep_deep_deep@email.address', firstName: 'should be snakify then hidden' } },
             access_token: 'secret',
+            items: [
+                { id: 1, organizationId: 'a' },
+                { id: 2, organizationId: 'b' },
+            ],
         };
         const logger = new Logger(metadata);
         logger.log('test', { errorContext: { errorCode: 200, errorMessage: 'Page Not Found' } });
@@ -139,6 +154,10 @@ describe('Logger', () => {
         assert.equal(actual['access_token'], '[REDACTED]');
         assert.deepEqual(actual['http'], { method: 'GET', status_code: 200, jwt: '[REDACTED]' });
         assert.deepEqual(actual['user']['contact'], { email: '[REDACTED]', first_name: '[REDACTED]' });
+        assert.deepEqual(actual['items'], [
+            { id: 1, organization_id: 'a' },
+            { id: 2, organization_id: 'b' },
+        ]);
     });
     it(`NULL_LOGGER should not log`, testContext => {
         const logger = NULL_LOGGER;
@@ -158,4 +177,77 @@ describe('Logger', () => {
         assert.strictEqual(infoSpy.mock.calls.length, 0);
         assert.strictEqual(debugSpy.mock.calls.length, 0);
     });
+    it('colorizes logs by status codes over log levels', () => {
+        const originalEnv = process.env.NODE_ENV;
+        const originalIsTTY = process.stdout.isTTY;
+        try {
+            process.env.NODE_ENV = 'development';
+            Object.defineProperty(process.stdout, 'isTTY', {
+                value: true,
+                configurable: true,
+            });
+            // 4xx status with warn level, should be red
+            const metadataWith400 = {
+                http: { status_code: 400 },
+            };
+            const redResult = Logger['colorize']('Some error', metadataWith400, 'warn');
+            // warn level without status code, should be yellow
+            const metadataNoStatus = {};
+            const yellowResult = Logger['colorize']('Some warning', metadataNoStatus, 'warn');
+            // Results should be different colors
+            assert.notEqual(redResult, yellowResult);
+            assert.ok(redResult.includes('\x1b[31m')); // Red color code
+            assert.ok(yellowResult.includes('\x1b[33m')); // Yellow color code
+        }
+        finally {
+            // Restore original values
+            process.env.NODE_ENV = originalEnv;
+            Object.defineProperty(process.stdout, 'isTTY', {
+                value: originalIsTTY,
+                configurable: true,
+            });
+        }
+    });
+    it('colorizes logs with different status code ranges', () => {
+        const originalEnv = process.env.NODE_ENV;
+        const originalIsTTY = process.stdout.isTTY;
+        try {
+            process.env.NODE_ENV = 'development';
+            Object.defineProperty(process.stdout, 'isTTY', {
+                value: true,
+                configurable: true,
+            });
+            // 2xx status codes should be green
+            const successMetadata = {
+                http: { status_code: 200 },
+            };
+            const greenResult = Logger['colorize']('Success', successMetadata, 'info');
+            assert.ok(greenResult.includes('\x1b[32m')); // Green color code
+            // 3xx status codes should be yellow
+            const redirectMetadata = {
+                http: { status_code: 301 },
+            };
+            const yellowResult = Logger['colorize']('Redirect', redirectMetadata, 'info');
+            assert.ok(yellowResult.includes('\x1b[33m')); // Yellow color code
+            // 4xx status codes should be red
+            const clientErrorMetadata = {
+                http: { status_code: 404 },
+            };
+            const redResult = Logger['colorize']('Not Found', clientErrorMetadata, 'warn');
+            assert.ok(redResult.includes('\x1b[31m')); // Red color code
+            // 5xx status codes should be red
+            const serverErrorMetadata = {
+                http: { status_code: 500 },
+            };
+            const redResult2 = Logger['colorize']('Server Error', serverErrorMetadata, 'error');
+            assert.ok(redResult2.includes('\x1b[31m')); // Red color code
+        }
+        finally {
+            process.env.NODE_ENV = originalEnv;
+            Object.defineProperty(process.stdout, 'isTTY', {
+                value: originalIsTTY,
+                configurable: true,
+            });
+        }
+    });
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@unito/integration-sdk",
-  "version": "2.3.2",
+  "version": "2.3.4",
   "description": "Integration SDK",
   "type": "module",
   "types": "dist/src/index.d.ts",

package/src/resources/logger.ts

@@ -1,3 +1,5 @@
+import { styleText } from 'util';
+
 const enum LogLevel {
   ERROR = 'error',
   WARN = 'warn',
@@ -8,7 +10,7 @@ const enum LogLevel {
 
 type PrimitiveValue = undefined | null | string | string[] | number | number[] | boolean | boolean[];
 type Value = {
-  [key: string]: PrimitiveValue | Value;
+  [key: string]: PrimitiveValue | Value | PrimitiveValue[] | Value[];
 };
 
 export type Metadata = Value & { message?: never };
@@ -162,7 +164,14 @@ export default class Logger {
     };
 
     if (process.env.NODE_ENV === 'development') {
-      console[logLevel](JSON.stringify(processedLogs, null, 2));
+      const coloredMessage = Logger.colorize(message, processedLogs, logLevel);
+
+      const metadata = {
+        date: new Date(processedLogs.date).toISOString(),
+        ...processedMetadata,
+      };
+
+      console[logLevel](`${coloredMessage} ${JSON.stringify(metadata, null, 2)}`);
     } else {
       console[logLevel](JSON.stringify(processedLogs));
     }
@@ -172,7 +181,16 @@ export default class Logger {
     const result: Value = {};
 
     for (const key in value) {
-      const deepValue = typeof value[key] === 'object' ? this.snakifyKeys(value[key] as Value) : value[key];
+      let deepValue;
+
+      if (Array.isArray(value[key])) {
+        deepValue = value[key].map(item => this.snakifyKeys(item as Value));
+      } else if (typeof value[key] === 'object' && value[key] !== null) {
+        deepValue = this.snakifyKeys(value[key] as Value);
+      } else {
+        deepValue = value[key];
+      }
+
       const snakifiedKey = key.replace(/[\w](?<!_)([A-Z])/g, k => `${k[0]}_${k[1]}`).toLowerCase();
       result[snakifiedKey] = deepValue;
     }
@@ -187,7 +205,11 @@ export default class Logger {
       if (LOGMETA_BLACKLIST.includes(key)) {
         prunedMetadata[key] = '[REDACTED]';
         (topLevelMeta ?? prunedMetadata).has_sensitive_attribute = true;
-      } else if (typeof metadata[key] === 'object') {
+      } else if (Array.isArray(metadata[key])) {
+        prunedMetadata[key] = metadata[key].map(value =>
+          Logger.pruneSensitiveMetadata(value as Value, topLevelMeta ?? prunedMetadata),
+        );
+      } else if (typeof metadata[key] === 'object' && metadata[key] !== null) {
         prunedMetadata[key] = Logger.pruneSensitiveMetadata(metadata[key] as Value, topLevelMeta ?? prunedMetadata);
       } else {
         prunedMetadata[key] = metadata[key];
@@ -196,6 +218,59 @@ export default class Logger {
 
     return prunedMetadata;
   }
+
+  /**
+   * Colorizes the log message based on the log level and status codes.
+   * @param message The message to colorize.
+   * @param metadata The metadata associated with the log.
+   * @param logLevel The log level of the message.
+   * @returns The colorized output string.
+   */
+  private static colorize(message: string, metadata: Value, logLevel: LogLevel): string {
+    if (!process.stdout.isTTY) {
+      return message;
+    }
+
+    const logOutput = `${logLevel}: ${message}`;
+
+    // Extract status code from logs
+    let statusCode: number | undefined;
+    if (metadata.http && typeof metadata.http === 'object' && !Array.isArray(metadata.http)) {
+      const statusCodeValue = metadata.http.status_code;
+
+      if (typeof statusCodeValue === 'number') {
+        statusCode = statusCodeValue;
+      } else if (typeof statusCodeValue === 'string') {
+        statusCode = parseInt(statusCodeValue, 10);
+      }
+    }
+
+    // Color based on status code first
+    if (statusCode) {
+      if (statusCode >= 400) {
+        return styleText('red', logOutput);
+      } else if (statusCode >= 300) {
+        return styleText('yellow', logOutput);
+      } else if (statusCode >= 200) {
+        return styleText('green', logOutput);
+      }
+    }
+
+    // Fall back to log level if no status code found
+    switch (logLevel) {
+      case LogLevel.ERROR:
+        return styleText('red', logOutput);
+      case LogLevel.WARN:
+        return styleText('yellow', logOutput);
+      case LogLevel.INFO:
+      case LogLevel.LOG:
+        return styleText('green', logOutput);
+      case LogLevel.DEBUG:
+        return styleText('cyan', logOutput);
+      default:
+        return logOutput;
+    }
+  }
 }
 
 export const NULL_LOGGER = new Logger({}, true);

package/test/resources/logger.test.ts

@@ -129,7 +129,14 @@ describe('Logger', () => {
     const logSpy = testContext.mock.method(global.console, 'log', () => {});
     assert.strictEqual(logSpy.mock.calls.length, 0);
 
-    const metadata = { correlationId: '123456789', http: { method: 'GET', statusCode: 200 } };
+    const metadata = {
+      correlationId: '123456789',
+      http: { method: 'GET', statusCode: 200 },
+      links: [
+        { id: 1, organizationId: 'a' },
+        { id: 2, organizationId: 'b' },
+      ],
+    };
     const logger = new Logger(metadata);
     logger.log('test', { errorContext: { errorCode: 200, errorMessage: 'Page Not Found' } });
     assert.strictEqual(logSpy.mock.calls.length, 1);
@@ -142,6 +149,10 @@ describe('Logger', () => {
     assert.equal(actual['status'], 'log');
     assert.deepEqual(actual['http'], { method: 'GET', status_code: 200 });
     assert.deepEqual(actual['error_context'], { error_code: 200, error_message: 'Page Not Found' });
+    assert.deepEqual(actual['links'], [
+      { id: 1, organization_id: 'a' },
+      { id: 2, organization_id: 'b' },
+    ]);
   });
 
   it('prunes sensitive Metadata', testContext => {
@@ -153,6 +164,10 @@ describe('Logger', () => {
       http: { method: 'GET', statusCode: 200, jwt: 'deepSecret' },
       user: { contact: { email: 'deep_deep_deep@email.address', firstName: 'should be snakify then hidden' } },
       access_token: 'secret',
+      items: [
+        { id: 1, organizationId: 'a' },
+        { id: 2, organizationId: 'b' },
+      ],
     };
     const logger = new Logger(metadata);
     logger.log('test', { errorContext: { errorCode: 200, errorMessage: 'Page Not Found' } });
@@ -167,6 +182,10 @@ describe('Logger', () => {
     assert.equal(actual['access_token'], '[REDACTED]');
     assert.deepEqual(actual['http'], { method: 'GET', status_code: 200, jwt: '[REDACTED]' });
     assert.deepEqual(actual['user']['contact'], { email: '[REDACTED]', first_name: '[REDACTED]' });
+    assert.deepEqual(actual['items'], [
+      { id: 1, organization_id: 'a' },
+      { id: 2, organization_id: 'b' },
+    ]);
   });
 
   it(`NULL_LOGGER should not log`, testContext => {
@@ -190,4 +209,86 @@ describe('Logger', () => {
     assert.strictEqual(infoSpy.mock.calls.length, 0);
     assert.strictEqual(debugSpy.mock.calls.length, 0);
   });
+
+  it('colorizes logs by status codes over log levels', () => {
+    const originalEnv = process.env.NODE_ENV;
+    const originalIsTTY = process.stdout.isTTY;
+
+    try {
+      process.env.NODE_ENV = 'development';
+      Object.defineProperty(process.stdout, 'isTTY', {
+        value: true,
+        configurable: true,
+      });
+
+      // 4xx status with warn level, should be red
+      const metadataWith400 = {
+        http: { status_code: 400 },
+      };
+      const redResult = Logger['colorize']('Some error', metadataWith400, 'warn' as any);
+
+      // warn level without status code, should be yellow
+      const metadataNoStatus = {};
+      const yellowResult = Logger['colorize']('Some warning', metadataNoStatus, 'warn' as any);
+
+      // Results should be different colors
+      assert.notEqual(redResult, yellowResult);
+      assert.ok(redResult.includes('\x1b[31m')); // Red color code
+      assert.ok(yellowResult.includes('\x1b[33m')); // Yellow color code
+    } finally {
+      // Restore original values
+      process.env.NODE_ENV = originalEnv;
+      Object.defineProperty(process.stdout, 'isTTY', {
+        value: originalIsTTY,
+        configurable: true,
+      });
+    }
+  });
+
+  it('colorizes logs with different status code ranges', () => {
+    const originalEnv = process.env.NODE_ENV;
+    const originalIsTTY = process.stdout.isTTY;
+
+    try {
+      process.env.NODE_ENV = 'development';
+      Object.defineProperty(process.stdout, 'isTTY', {
+        value: true,
+        configurable: true,
+      });
+
+      // 2xx status codes should be green
+      const successMetadata = {
+        http: { status_code: 200 },
+      };
+      const greenResult = Logger['colorize']('Success', successMetadata, 'info' as any);
+      assert.ok(greenResult.includes('\x1b[32m')); // Green color code
+
+      // 3xx status codes should be yellow
+      const redirectMetadata = {
+        http: { status_code: 301 },
+      };
+      const yellowResult = Logger['colorize']('Redirect', redirectMetadata, 'info' as any);
+      assert.ok(yellowResult.includes('\x1b[33m')); // Yellow color code
+
+      // 4xx status codes should be red
+      const clientErrorMetadata = {
+        http: { status_code: 404 },
+      };
+      const redResult = Logger['colorize']('Not Found', clientErrorMetadata, 'warn' as any);
+      assert.ok(redResult.includes('\x1b[31m')); // Red color code
+
+      // 5xx status codes should be red
+      const serverErrorMetadata = {
+        http: { status_code: 500 },
+      };
+      const redResult2 = Logger['colorize']('Server Error', serverErrorMetadata, 'error' as any);
+      assert.ok(redResult2.includes('\x1b[31m')); // Red color code
+    } finally {
+      process.env.NODE_ENV = originalEnv;
+      Object.defineProperty(process.stdout, 'isTTY', {
+        value: originalIsTTY,
+        configurable: true,
+      });
+    }
+  });
 });