How to use the kyt-utils/logger.error function in kyt-utils

const normalizeDep = (prefix, dep) => {
  let resolved;
  try {
    // Prefix babel when babel doesn't exist
    if (dep.indexOf('babel') < 0) {
      resolved = resolve.sync(`${prefix}-${dep}`, { basedir: userRootPath });
    }
    return resolved || resolve.sync(dep, { basedir: userRootPath });
  } catch (e) {
    logger.error('Could not resolve dependency', dep);
    logger.error('Error output', e);
    logger.error('Exiting...');
    return process.exit(1);
  }
};

compiler = webpack(webpackConfig);
    } catch (error) {
      logger.error('Webpack config is invalid\n', error);
      process.exit();
    }

    // Creates a webpack dev server at the specified port
    server = new WebpackDevServer(compiler, webpackConfig.devServer);
    server.listen(prototypeURL.port, prototypeURL.hostname, () => {
      logger.end(`webpack-dev-server ${prototypeURL.href}prototype`);
    });
  };
  logger.start('Configuring Prototype...');

  if (!shell.test('-f', userPrototypePath)) {
    logger.error('Prototype.js entry file does not exist.');
    logger.error('See the kyt Readme for details.');
    process.exit();
  }

  ifPortIsFreeDo(prototypeURL.port, startPrototype);
};

const normalizeDep = (prefix, dep) => {
  let resolved;
  try {
    // Prefix babel when babel doesn't exist
    if (dep.indexOf('babel') < 0) {
      resolved = resolve.sync(`${prefix}-${dep}`, { basedir: userRootPath });
    }
    return resolved || resolve.sync(dep, { basedir: userRootPath });
  } catch (e) {
    logger.error('Could not resolve dependency', dep);
    logger.error('Error output', e);
    logger.error('Exiting...');
    return process.exit(1);
  }
};

const normalizeDep = (prefix, dep) => {
  let resolved;
  try {
    // Prefix babel when babel doesn't exist
    if (dep.indexOf('babel') < 0) {
      resolved = resolve.sync(`${prefix}-${dep}`, { basedir: userRootPath });
    }
    return resolved || resolve.sync(dep, { basedir: userRootPath });
  } catch (e) {
    logger.error('Could not resolve dependency', dep);
    logger.error('Error output', e);
    logger.error('Exiting...');
    return process.exit(1);
  }
};

module.exports = (webpackConfig, cb) => {
  let webpackCompiler;
  const type = webpackConfig.target === 'web' ? 'Client' : 'Server';

  // Compile the webpack config
  try {
    webpackCompiler = webpack(webpackConfig);
    logger.task(`${type} webpack configuration compiled`);
  } catch (error) {
    logger.error(`${type} webpack config is invalid\n`, error);
    process.exit();
  }

  webpackCompiler.hooks.beforeRun.tap('kyt', () => {
    // Temporarily set the build type in the process.
    // This is used by the babel-preset-kyt-core plugin.
    process.env.KYT_ENV_TYPE = type.toLowerCase();
  });

  // Handle errors in webpack build
  webpackCompiler.hooks.done.tap('kyt', stats => {
    if (stats.hasErrors()) {
      logger.error(`${type} build failed\n`, stats.toString());
      logger.info('See webpack error above');
    } else if (stats.hasWarnings()) {
      logger.warn(`${type} build warnings`, stats.toJson().warnings.join('\n'));

clientConfig = config.modifyWebpackConfig(clone(clientConfig), clientOptions);
    serverConfig = config.modifyWebpackConfig(clone(serverConfig), serverOptions);
  } catch (error) {
    logger.error('Error in your kyt.config.js modifyWebpackConfig():', error);
    process.exit(1);
  }

  if (config.debug) {
    logger.debug('Client webpack configuration:', clientConfig);
    logger.debug('\n\n');
    logger.debug('Server webpack configuration:', serverConfig);
  }

  // A "main" entry is required in the server config.
  if (!serverConfig.entry.main) {
    logger.error(
      'A main entry is required in the server configuration. Found: ',
      serverConfig.entry
    );
    process.exit(1);
  }

  return {
    clientConfig,
    serverConfig,
  };
};

webpackCompiler.hooks.done.tap('kyt', stats => {
    if (stats.hasErrors()) {
      logger.error(`${type} build failed\n`, stats.toString());
      logger.info('See webpack error above');
    } else if (stats.hasWarnings()) {
      logger.warn(`${type} build warnings`, stats.toJson().warnings.join('\n'));
    } else {
      logger.task(`${type} build successful`);
    }

    // Remove the build type that we set in the "before-run" hook.
    delete process.env.KYT_ENV_TYPE;

    // Call the callback on successful build
    if (cb) {
      cb(stats);
    }
  });

const handleError = error => {
    logger.error(error);
    process.exit(1);
  };

detect(port, (error, unusedPort) => {
    if (error) {
      logger.error('error attempting to detect port', error);
      process.exit();
    }

    if (port === unusedPort) {
      callback();
    } else {
      logger.error(`port: ${port} is in use.`);
      logger.info('Ports can be configured in kyt.config.js');
      process.exit();
    }
  });
};

const installUserDependencies = () => {
    logger.info('Cleaning node modules and reinstalling. This may take a couple of minutes...');
    shell.rm('-rf', paths.userNodeModulesPath);
    const result = shell.exec(`${ypm} install`);
    if (result.code !== 0) {
      fs.writeFileSync(paths.userPackageJSONPath, JSON.stringify(oldPackageJSON, null, 2));
      logger.error('An error occurred when trying to install node modules', result.stderr);
      logger.task('Restored the original package.json and bailing');
      logger.info('You may need to reinstall your modules');
      bailProcess();
    }
    logger.task('Installed new modules');
  };