@verdaccio/canary 6.3.2-canary.404363f

package/build/api/web/api/user.js

@@ -0,0 +1,70 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _express = require("express");
+var _lodash = _interopRequireDefault(require("lodash"));
+var _core = require("@verdaccio/core");
+var _middleware = require("@verdaccio/middleware");
+var _authUtils = require("../../../lib/auth-utils");
+var _constants = require("../../../lib/constants");
+var _utils = require("../../../lib/utils");
+var _utils2 = require("./utils");
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+function addUserAuthApi(auth, config) {
+  /* eslint new-cap:off */
+  const route = (0, _express.Router)();
+  route.post((0, _utils2.wrapSecPath)(_middleware.WebUrls.user_login), (0, _middleware.rateLimit)(config?.userRateLimit), function (req, res, next) {
+    const {
+      username,
+      password
+    } = req.body;
+    auth.authenticate(username, password, async (err, user) => {
+      if (err) {
+        const errorCode = err.message ? _constants.HTTP_STATUS.UNAUTHORIZED : _constants.HTTP_STATUS.INTERNAL_ERROR;
+        next(_utils.ErrorCode.getCode(errorCode, err.message));
+      } else {
+        req.remote_user = user;
+        const jWTSignOptions = (0, _authUtils.getSecurity)(config).web.sign;
+        res.set(_constants.HEADERS.CACHE_CONTROL, 'no-cache, no-store');
+        next({
+          token: await auth.jwtEncrypt(user, jWTSignOptions),
+          username: req.remote_user.name
+        });
+      }
+    });
+  });
+  route.put((0, _utils2.wrapSecPath)(_middleware.WebUrls.reset_password), function (req, res, next) {
+    if (_lodash.default.isNil(req.remote_user.name)) {
+      res.status(_constants.HTTP_STATUS.UNAUTHORIZED);
+      return next({
+        // FUTURE: update to a more meaningful message
+        message: _constants.API_ERROR.MUST_BE_LOGGED
+      });
+    }
+    const {
+      password
+    } = req.body;
+    const {
+      name
+    } = req.remote_user;
+    if (_core.validationUtils.validatePassword(password.new) === false) {
+      auth.changePassword(name, password.old, password.new, (err, isUpdated) => {
+        if (_lodash.default.isNil(err) && isUpdated) {
+          next({
+            ok: true
+          });
+        } else {
+          return next(_utils.ErrorCode.getInternalError(_constants.API_ERROR.INTERNAL_SERVER_ERROR));
+        }
+      });
+    } else {
+      return next(_utils.ErrorCode.getCode(_constants.HTTP_STATUS.BAD_REQUEST, _constants.APP_ERROR.PASSWORD_VALIDATION));
+    }
+  });
+  return route;
+}
+var _default = exports.default = addUserAuthApi;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/build/api/web/api/utils.js

@@ -0,0 +1,14 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.wrapPath = wrapPath;
+exports.wrapSecPath = wrapSecPath;
+function wrapPath(urlPath) {
+  return `/-/verdaccio/data${urlPath}`;
+}
+function wrapSecPath(urlPath) {
+  return `/-/verdaccio/sec${urlPath}`;
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJuYW1lcyI6WyJ3cmFwUGF0aCIsInVybFBhdGgiLCJ3cmFwU2VjUGF0aCJdLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3NyYy9hcGkvd2ViL2FwaS91dGlscy50cyJdLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgZnVuY3Rpb24gd3JhcFBhdGgodXJsUGF0aDogc3RyaW5nKSB7XG4gIHJldHVybiBgLy0vdmVyZGFjY2lvL2RhdGEke3VybFBhdGh9YDtcbn1cblxuZXhwb3J0IGZ1bmN0aW9uIHdyYXBTZWNQYXRoKHVybFBhdGg6IHN0cmluZykge1xuICByZXR1cm4gYC8tL3ZlcmRhY2Npby9zZWMke3VybFBhdGh9YDtcbn1cbiJdLCJtYXBwaW5ncyI6Ijs7Ozs7OztBQUFPLFNBQVNBLFFBQVFBLENBQUNDLE9BQWUsRUFBRTtFQUN4QyxPQUFPLG9CQUFvQkEsT0FBTyxFQUFFO0FBQ3RDO0FBRU8sU0FBU0MsV0FBV0EsQ0FBQ0QsT0FBZSxFQUFFO0VBQzNDLE9BQU8sbUJBQW1CQSxPQUFPLEVBQUU7QUFDckMiLCJpZ25vcmVMaXN0IjpbXX0=

package/build/api/web/index.js

@@ -0,0 +1,96 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = exports.PLUGIN_UI_PREFIX = exports.DEFAULT_PLUGIN_UI_THEME = void 0;
+exports.loadTheme = loadTheme;
+exports.webAPIMiddleware = webAPIMiddleware;
+exports.webMiddleware = webMiddleware;
+var _debug = _interopRequireDefault(require("debug"));
+var _express = _interopRequireWildcard(require("express"));
+var _lodash = _interopRequireDefault(require("lodash"));
+var _core = require("@verdaccio/core");
+var _loaders = require("@verdaccio/loaders");
+var _logger = require("@verdaccio/logger");
+var _middleware = require("@verdaccio/middleware");
+var _uiTheme = _interopRequireDefault(require("@verdaccio/ui-theme"));
+var _api = _interopRequireDefault(require("./api"));
+function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function (e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (const t in e) "default" !== t && {}.hasOwnProperty.call(e, t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, t)) && (i.get || i.set) ? o(f, t, i) : f[t] = e[t]); return f; })(e, t); }
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+const debug = (0, _debug.default)('verdaccio:web');
+const PLUGIN_UI_PREFIX = exports.PLUGIN_UI_PREFIX = 'verdaccio-theme';
+const DEFAULT_PLUGIN_UI_THEME = exports.DEFAULT_PLUGIN_UI_THEME = '@verdaccio/ui-theme';
+async function loadTheme(config) {
+  if (_lodash.default.isNil(config.theme) === false) {
+    const plugin = await (0, _loaders.asyncLoadPlugin)(config.theme, {
+      config,
+      logger: _logger.logger
+    },
+    // TODO: add types { staticPath: string; manifest: unknown; manifestFiles: unknown }
+    function (plugin) {
+      /**
+               *
+               - `staticPath`: is the same data returned in Verdaccio 5.
+               - `manifest`: A webpack manifest object.
+               - `manifestFiles`: A object with one property `js` and the array (order matters) of the manifest id to be loaded in the template dynamically.
+               */
+      return plugin.staticPath && plugin.manifest && plugin.manifestFiles;
+    }, true, config?.serverSettings?.pluginPrefix ?? PLUGIN_UI_PREFIX, _core.PLUGIN_CATEGORY.THEME);
+    if (plugin.length > 1) {
+      _logger.logger.warn('multiple ui themes are not supported; only the first plugin is used');
+    }
+    return _lodash.default.head(plugin);
+  }
+}
+function webAPIMiddleware(tokenMiddleware, webEndpointsApi) {
+  const route = (0, _express.Router)();
+  // validate all of these params as a package name
+  // this might be too harsh, so ask if it causes trouble=
+  route.param('package', _middleware.validatePackage);
+  route.param('filename', _middleware.validateName);
+  route.param('version', _middleware.validateName);
+  route.use(_express.default.urlencoded({
+    extended: false
+  }));
+  route.use(_middleware.setSecurityWebHeaders);
+  if (typeof tokenMiddleware === 'function') {
+    route.use(tokenMiddleware);
+  }
+  if (typeof webEndpointsApi === 'function') {
+    route.use(webEndpointsApi);
+  }
+  return route;
+}
+function webMiddleware(config, middlewares, pluginOptions) {
+  const router = _express.default.Router();
+  const {
+    tokenMiddleware,
+    webEndpointsApi
+  } = middlewares;
+  // render web
+  router.use(_middleware.WebUrlsNamespace.root, (0, _middleware.renderWebMiddleware)(config, tokenMiddleware, pluginOptions));
+  // web endpoints: search, packages, readme, sidebar, etc
+  router.use(_middleware.WebUrlsNamespace.endpoints, webAPIMiddleware(tokenMiddleware, webEndpointsApi));
+  return router;
+}
+var _default = async (config, auth, storage, logger) => {
+  let pluginOptions = await loadTheme(config);
+  if (!pluginOptions) {
+    debug('no theme plugin found, using default theme');
+    pluginOptions = (0, _uiTheme.default)(config.web);
+    logger.info({
+      name: DEFAULT_PLUGIN_UI_THEME,
+      pluginCategory: _core.PLUGIN_CATEGORY.THEME
+    }, 'plugin @{name} successfully loaded (@{pluginCategory})');
+  }
+  const router = (0, _express.Router)();
+  // web endpoints, search, packages, etc
+  router.use(webMiddleware(config, {
+    tokenMiddleware: auth.webUIJWTmiddleware(),
+    webEndpointsApi: (0, _api.default)(auth, storage, config)
+  }, pluginOptions));
+  return router;
+};
+exports.default = _default;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["_debug","_interopRequireDefault","require","_express","_interopRequireWildcard","_lodash","_core","_loaders","_logger","_middleware","_uiTheme","_api","e","t","WeakMap","r","n","__esModule","o","i","f","__proto__","default","has","get","set","hasOwnProperty","call","Object","defineProperty","getOwnPropertyDescriptor","debug","buildDebug","PLUGIN_UI_PREFIX","exports","DEFAULT_PLUGIN_UI_THEME","loadTheme","config","_","isNil","theme","plugin","asyncLoadPlugin","logger","staticPath","manifest","manifestFiles","serverSettings","pluginPrefix","PLUGIN_CATEGORY","THEME","length","warn","head","webAPIMiddleware","tokenMiddleware","webEndpointsApi","route","Router","param","validatePackage","validateName","use","express","urlencoded","extended","setSecurityWebHeaders","webMiddleware","middlewares","pluginOptions","router","WebUrlsNamespace","root","renderWebMiddleware","endpoints","_default","auth","storage","defaultTheme","web","info","name","pluginCategory","webUIJWTmiddleware"],"sources":["../../../src/api/web/index.ts"],"sourcesContent":["import buildDebug from 'debug';\nimport type { RequestHandler } from 'express';\nimport express, { Router } from 'express';\nimport _ from 'lodash';\n\nimport { PLUGIN_CATEGORY } from '@verdaccio/core';\nimport { asyncLoadPlugin } from '@verdaccio/loaders';\nimport { logger } from '@verdaccio/logger';\nimport {\n  WebUrlsNamespace,\n  renderWebMiddleware,\n  setSecurityWebHeaders,\n  validateName,\n  validatePackage,\n} from '@verdaccio/middleware';\nimport defaultTheme from '@verdaccio/ui-theme';\n\nimport webEndpointsApi from './api';\n\nconst debug = buildDebug('verdaccio:web');\nexport const PLUGIN_UI_PREFIX = 'verdaccio-theme';\nexport const DEFAULT_PLUGIN_UI_THEME = '@verdaccio/ui-theme';\n\nexport async function loadTheme(config: any) {\n  if (_.isNil(config.theme) === false) {\n    const plugin = await asyncLoadPlugin(\n      config.theme,\n      { config, logger },\n      // TODO: add types { staticPath: string; manifest: unknown; manifestFiles: unknown }\n      function (plugin: any) {\n        /**\n                 *\n                 - `staticPath`: is the same data returned in Verdaccio 5.\n                 - `manifest`: A webpack manifest object.\n                 - `manifestFiles`: A object with one property `js` and the array (order matters) of the manifest id to be loaded in the template dynamically.\n                 */\n        return plugin.staticPath && plugin.manifest && plugin.manifestFiles;\n      },\n      true,\n      config?.serverSettings?.pluginPrefix ?? PLUGIN_UI_PREFIX,\n      PLUGIN_CATEGORY.THEME\n    );\n    if (plugin.length > 1) {\n      logger.warn('multiple ui themes are not supported; only the first plugin is used');\n    }\n\n    return _.head(plugin);\n  }\n}\n\nexport function webAPIMiddleware(\n  tokenMiddleware: RequestHandler,\n  webEndpointsApi: RequestHandler\n): Router {\n  const route = Router();\n  // validate all of these params as a package name\n  // this might be too harsh, so ask if it causes trouble=\n  route.param('package', validatePackage);\n  route.param('filename', validateName);\n  route.param('version', validateName);\n  route.use(express.urlencoded({ extended: false }));\n  route.use(setSecurityWebHeaders);\n\n  if (typeof tokenMiddleware === 'function') {\n    route.use(tokenMiddleware);\n  }\n\n  if (typeof webEndpointsApi === 'function') {\n    route.use(webEndpointsApi);\n  }\n\n  return route;\n}\n\nexport function webMiddleware(config, middlewares, pluginOptions): any {\n  const router = express.Router();\n  const { tokenMiddleware, webEndpointsApi } = middlewares;\n  // render web\n  router.use(WebUrlsNamespace.root, renderWebMiddleware(config, tokenMiddleware, pluginOptions));\n  // web endpoints: search, packages, readme, sidebar, etc\n  router.use(WebUrlsNamespace.endpoints, webAPIMiddleware(tokenMiddleware, webEndpointsApi));\n  return router;\n}\n\nexport default async (config, auth, storage, logger) => {\n  let pluginOptions = await loadTheme(config);\n  if (!pluginOptions) {\n    debug('no theme plugin found, using default theme');\n    pluginOptions = defaultTheme(config.web);\n    logger.info(\n      { name: DEFAULT_PLUGIN_UI_THEME, pluginCategory: PLUGIN_CATEGORY.THEME },\n      'plugin @{name} successfully loaded (@{pluginCategory})'\n    );\n  }\n\n  const router = Router();\n  // web endpoints, search, packages, etc\n  router.use(\n    webMiddleware(\n      config,\n      {\n        tokenMiddleware: auth.webUIJWTmiddleware(),\n        webEndpointsApi: webEndpointsApi(auth, storage, config),\n      },\n      pluginOptions\n    )\n  );\n  return router;\n};\n"],"mappings":";;;;;;;;;AAAA,IAAAA,MAAA,GAAAC,sBAAA,CAAAC,OAAA;AAEA,IAAAC,QAAA,GAAAC,uBAAA,CAAAF,OAAA;AACA,IAAAG,OAAA,GAAAJ,sBAAA,CAAAC,OAAA;AAEA,IAAAI,KAAA,GAAAJ,OAAA;AACA,IAAAK,QAAA,GAAAL,OAAA;AACA,IAAAM,OAAA,GAAAN,OAAA;AACA,IAAAO,WAAA,GAAAP,OAAA;AAOA,IAAAQ,QAAA,GAAAT,sBAAA,CAAAC,OAAA;AAEA,IAAAS,IAAA,GAAAV,sBAAA,CAAAC,OAAA;AAAoC,SAAAE,wBAAAQ,CAAA,EAAAC,CAAA,6BAAAC,OAAA,MAAAC,CAAA,OAAAD,OAAA,IAAAE,CAAA,OAAAF,OAAA,YAAAV,uBAAA,YAAAA,CAAAQ,CAAA,EAAAC,CAAA,SAAAA,CAAA,IAAAD,CAAA,IAAAA,CAAA,CAAAK,UAAA,SAAAL,CAAA,MAAAM,CAAA,EAAAC,CAAA,EAAAC,CAAA,KAAAC,SAAA,QAAAC,OAAA,EAAAV,CAAA,iBAAAA,CAAA,uBAAAA,CAAA,yBAAAA,CAAA,SAAAQ,CAAA,MAAAF,CAAA,GAAAL,CAAA,GAAAG,CAAA,GAAAD,CAAA,QAAAG,CAAA,CAAAK,GAAA,CAAAX,CAAA,UAAAM,CAAA,CAAAM,GAAA,CAAAZ,CAAA,GAAAM,CAAA,CAAAO,GAAA,CAAAb,CAAA,EAAAQ,CAAA,gBAAAP,CAAA,IAAAD,CAAA,gBAAAC,CAAA,OAAAa,cAAA,CAAAC,IAAA,CAAAf,CAAA,EAAAC,CAAA,OAAAM,CAAA,IAAAD,CAAA,GAAAU,MAAA,CAAAC,cAAA,KAAAD,MAAA,CAAAE,wBAAA,CAAAlB,CAAA,EAAAC,CAAA,OAAAM,CAAA,CAAAK,GAAA,IAAAL,CAAA,CAAAM,GAAA,IAAAP,CAAA,CAAAE,CAAA,EAAAP,CAAA,EAAAM,CAAA,IAAAC,CAAA,CAAAP,CAAA,IAAAD,CAAA,CAAAC,CAAA,WAAAO,CAAA,KAAAR,CAAA,EAAAC,CAAA;AAAA,SAAAZ,uBAAAW,CAAA,WAAAA,CAAA,IAAAA,CAAA,CAAAK,UAAA,GAAAL,CAAA,KAAAU,OAAA,EAAAV,CAAA;AAEpC,MAAMmB,KAAK,GAAG,IAAAC,cAAU,EAAC,eAAe,CAAC;AAClC,MAAMC,gBAAgB,GAAAC,OAAA,CAAAD,gBAAA,GAAG,iBAAiB;AAC1C,MAAME,uBAAuB,GAAAD,OAAA,CAAAC,uBAAA,GAAG,qBAAqB;AAErD,eAAeC,SAASA,CAACC,MAAW,EAAE;EAC3C,IAAIC,eAAC,CAACC,KAAK,CAACF,MAAM,CAACG,KAAK,CAAC,KAAK,KAAK,EAAE;IACnC,MAAMC,MAAM,GAAG,MAAM,IAAAC,wBAAe,EAClCL,MAAM,CAACG,KAAK,EACZ;MAAEH,MAAM;MAAEM,MAAM,EAANA;IAAO,CAAC;IAClB;IACA,UAAUF,MAAW,EAAE;MACrB;AACR;AACA;AACA;AACA;AACA;MACQ,OAAOA,MAAM,CAACG,UAAU,IAAIH,MAAM,CAACI,QAAQ,IAAIJ,MAAM,CAACK,aAAa;IACrE,CAAC,EACD,IAAI,EACJT,MAAM,EAAEU,cAAc,EAAEC,YAAY,IAAIf,gBAAgB,EACxDgB,qBAAe,CAACC,KAClB,CAAC;IACD,IAAIT,MAAM,CAACU,MAAM,GAAG,CAAC,EAAE;MACrBR,cAAM,CAACS,IAAI,CAAC,qEAAqE,CAAC;IACpF;IAEA,OAAOd,eAAC,CAACe,IAAI,CAACZ,MAAM,CAAC;EACvB;AACF;AAEO,SAASa,gBAAgBA,CAC9BC,eAA+B,EAC/BC,eAA+B,EACvB;EACR,MAAMC,KAAK,GAAG,IAAAC,eAAM,EAAC,CAAC;EACtB;EACA;EACAD,KAAK,CAACE,KAAK,CAAC,SAAS,EAAEC,2BAAe,CAAC;EACvCH,KAAK,CAACE,KAAK,CAAC,UAAU,EAAEE,wBAAY,CAAC;EACrCJ,KAAK,CAACE,KAAK,CAAC,SAAS,EAAEE,wBAAY,CAAC;EACpCJ,KAAK,CAACK,GAAG,CAACC,gBAAO,CAACC,UAAU,CAAC;IAAEC,QAAQ,EAAE;EAAM,CAAC,CAAC,CAAC;EAClDR,KAAK,CAACK,GAAG,CAACI,iCAAqB,CAAC;EAEhC,IAAI,OAAOX,eAAe,KAAK,UAAU,EAAE;IACzCE,KAAK,CAACK,GAAG,CAACP,eAAe,CAAC;EAC5B;EAEA,IAAI,OAAOC,eAAe,KAAK,UAAU,EAAE;IACzCC,KAAK,CAACK,GAAG,CAACN,eAAe,CAAC;EAC5B;EAEA,OAAOC,KAAK;AACd;AAEO,SAASU,aAAaA,CAAC9B,MAAM,EAAE+B,WAAW,EAAEC,aAAa,EAAO;EACrE,MAAMC,MAAM,GAAGP,gBAAO,CAACL,MAAM,CAAC,CAAC;EAC/B,MAAM;IAAEH,eAAe;IAAEC;EAAgB,CAAC,GAAGY,WAAW;EACxD;EACAE,MAAM,CAACR,GAAG,CAACS,4BAAgB,CAACC,IAAI,EAAE,IAAAC,+BAAmB,EAACpC,MAAM,EAAEkB,eAAe,EAAEc,aAAa,CAAC,CAAC;EAC9F;EACAC,MAAM,CAACR,GAAG,CAACS,4BAAgB,CAACG,SAAS,EAAEpB,gBAAgB,CAACC,eAAe,EAAEC,eAAe,CAAC,CAAC;EAC1F,OAAOc,MAAM;AACf;AAAC,IAAAK,QAAA,GAEc,MAAAA,CAAOtC,MAAM,EAAEuC,IAAI,EAAEC,OAAO,EAAElC,MAAM,KAAK;EACtD,IAAI0B,aAAa,GAAG,MAAMjC,SAAS,CAACC,MAAM,CAAC;EAC3C,IAAI,CAACgC,aAAa,EAAE;IAClBtC,KAAK,CAAC,4CAA4C,CAAC;IACnDsC,aAAa,GAAG,IAAAS,gBAAY,EAACzC,MAAM,CAAC0C,GAAG,CAAC;IACxCpC,MAAM,CAACqC,IAAI,CACT;MAAEC,IAAI,EAAE9C,uBAAuB;MAAE+C,cAAc,EAAEjC,qBAAe,CAACC;IAAM,CAAC,EACxE,wDACF,CAAC;EACH;EAEA,MAAMoB,MAAM,GAAG,IAAAZ,eAAM,EAAC,CAAC;EACvB;EACAY,MAAM,CAACR,GAAG,CACRK,aAAa,CACX9B,MAAM,EACN;IACEkB,eAAe,EAAEqB,IAAI,CAACO,kBAAkB,CAAC,CAAC;IAC1C3B,eAAe,EAAE,IAAAA,YAAe,EAACoB,IAAI,EAAEC,OAAO,EAAExC,MAAM;EACxD,CAAC,EACDgC,aACF,CACF,CAAC;EACD,OAAOC,MAAM;AACf,CAAC;AAAApC,OAAA,CAAAZ,OAAA,GAAAqD,QAAA","ignoreList":[]}

package/build/index.js

@@ -0,0 +1,76 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "Config", {
+  enumerable: true,
+  get: function () {
+    return _config.Config;
+  }
+});
+Object.defineProperty(exports, "ConfigBuilder", {
+  enumerable: true,
+  get: function () {
+    return _config.ConfigBuilder;
+  }
+});
+Object.defineProperty(exports, "cryptoUtils", {
+  enumerable: true,
+  get: function () {
+    return _core.cryptoUtils;
+  }
+});
+Object.defineProperty(exports, "default", {
+  enumerable: true,
+  get: function () {
+    return _bootstrap.startVerdaccio;
+  }
+});
+Object.defineProperty(exports, "errorUtils", {
+  enumerable: true,
+  get: function () {
+    return _core.errorUtils;
+  }
+});
+Object.defineProperty(exports, "fileUtils", {
+  enumerable: true,
+  get: function () {
+    return _core.fileUtils;
+  }
+});
+Object.defineProperty(exports, "getDefaultConfig", {
+  enumerable: true,
+  get: function () {
+    return _config.getDefaultConfig;
+  }
+});
+Object.defineProperty(exports, "parseConfigFile", {
+  enumerable: true,
+  get: function () {
+    return _config.parseConfigFile;
+  }
+});
+Object.defineProperty(exports, "pkgUtils", {
+  enumerable: true,
+  get: function () {
+    return _core.pkgUtils;
+  }
+});
+Object.defineProperty(exports, "runServer", {
+  enumerable: true,
+  get: function () {
+    return _runServer.runServer;
+  }
+});
+Object.defineProperty(exports, "startVerdaccio", {
+  enumerable: true,
+  get: function () {
+    return _bootstrap.startVerdaccio;
+  }
+});
+var _bootstrap = require("./lib/bootstrap");
+var _runServer = require("./lib/run-server");
+var _config = require("@verdaccio/config");
+var _core = require("@verdaccio/core");
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJuYW1lcyI6WyJfYm9vdHN0cmFwIiwicmVxdWlyZSIsIl9ydW5TZXJ2ZXIiLCJfY29uZmlnIiwiX2NvcmUiXSwic291cmNlcyI6WyIuLi9zcmMvaW5kZXgudHMiXSwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0IHsgc3RhcnRWZXJkYWNjaW8gYXMgZGVmYXVsdCwgc3RhcnRWZXJkYWNjaW8gfSBmcm9tICcuL2xpYi9ib290c3RyYXAnO1xuZXhwb3J0IHsgcnVuU2VydmVyIH0gZnJvbSAnLi9saWIvcnVuLXNlcnZlcic7XG5leHBvcnQgeyBDb25maWdCdWlsZGVyLCBwYXJzZUNvbmZpZ0ZpbGUsIGdldERlZmF1bHRDb25maWcsIENvbmZpZyB9IGZyb20gJ0B2ZXJkYWNjaW8vY29uZmlnJztcbmV4cG9ydCB7IGZpbGVVdGlscywgZXJyb3JVdGlscywgY3J5cHRvVXRpbHMsIHBrZ1V0aWxzIH0gZnJvbSAnQHZlcmRhY2Npby9jb3JlJztcbiJdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7QUFBQSxJQUFBQSxVQUFBLEdBQUFDLE9BQUE7QUFDQSxJQUFBQyxVQUFBLEdBQUFELE9BQUE7QUFDQSxJQUFBRSxPQUFBLEdBQUFGLE9BQUE7QUFDQSxJQUFBRyxLQUFBLEdBQUFILE9BQUEiLCJpZ25vcmVMaXN0IjpbXX0=

package/build/lib/auth-utils.js

@@ -0,0 +1,16 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getSecurity = getSecurity;
+var _lodash = _interopRequireDefault(require("lodash"));
+var _config = require("@verdaccio/config");
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+function getSecurity(config) {
+  if (_lodash.default.isNil(config.security) === false) {
+    return _lodash.default.merge(_config.defaultSecurity, config.security);
+  }
+  return _config.defaultSecurity;
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJuYW1lcyI6WyJfbG9kYXNoIiwiX2ludGVyb3BSZXF1aXJlRGVmYXVsdCIsInJlcXVpcmUiLCJfY29uZmlnIiwiZSIsIl9fZXNNb2R1bGUiLCJkZWZhdWx0IiwiZ2V0U2VjdXJpdHkiLCJjb25maWciLCJfIiwiaXNOaWwiLCJzZWN1cml0eSIsIm1lcmdlIiwiZGVmYXVsdFNlY3VyaXR5Il0sInNvdXJjZXMiOlsiLi4vLi4vc3JjL2xpYi9hdXRoLXV0aWxzLnRzIl0sInNvdXJjZXNDb250ZW50IjpbImltcG9ydCBfIGZyb20gJ2xvZGFzaCc7XG5cbmltcG9ydCB7IGRlZmF1bHRTZWN1cml0eSB9IGZyb20gJ0B2ZXJkYWNjaW8vY29uZmlnJztcbmltcG9ydCB7IENvbmZpZywgU2VjdXJpdHkgfSBmcm9tICdAdmVyZGFjY2lvL3R5cGVzJztcblxuZXhwb3J0IGZ1bmN0aW9uIGdldFNlY3VyaXR5KGNvbmZpZzogQ29uZmlnKTogU2VjdXJpdHkge1xuICBpZiAoXy5pc05pbChjb25maWcuc2VjdXJpdHkpID09PSBmYWxzZSkge1xuICAgIHJldHVybiBfLm1lcmdlKGRlZmF1bHRTZWN1cml0eSwgY29uZmlnLnNlY3VyaXR5KTtcbiAgfVxuXG4gIHJldHVybiBkZWZhdWx0U2VjdXJpdHk7XG59XG4iXSwibWFwcGluZ3MiOiI7Ozs7OztBQUFBLElBQUFBLE9BQUEsR0FBQUMsc0JBQUEsQ0FBQUMsT0FBQTtBQUVBLElBQUFDLE9BQUEsR0FBQUQsT0FBQTtBQUFvRCxTQUFBRCx1QkFBQUcsQ0FBQSxXQUFBQSxDQUFBLElBQUFBLENBQUEsQ0FBQUMsVUFBQSxHQUFBRCxDQUFBLEtBQUFFLE9BQUEsRUFBQUYsQ0FBQTtBQUc3QyxTQUFTRyxXQUFXQSxDQUFDQyxNQUFjLEVBQVk7RUFDcEQsSUFBSUMsZUFBQyxDQUFDQyxLQUFLLENBQUNGLE1BQU0sQ0FBQ0csUUFBUSxDQUFDLEtBQUssS0FBSyxFQUFFO0lBQ3RDLE9BQU9GLGVBQUMsQ0FBQ0csS0FBSyxDQUFDQyx1QkFBZSxFQUFFTCxNQUFNLENBQUNHLFFBQVEsQ0FBQztFQUNsRDtFQUVBLE9BQU9FLHVCQUFlO0FBQ3hCIiwiaWdub3JlTGlzdCI6W119

package/build/lib/bootstrap.js

@@ -0,0 +1,167 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.listenDefaultCallback = listenDefaultCallback;
+exports.startVerdaccio = startVerdaccio;
+var _console = require("console");
+var _constants = _interopRequireDefault(require("constants"));
+var _fs = _interopRequireDefault(require("fs"));
+var _http = _interopRequireDefault(require("http"));
+var _https = _interopRequireDefault(require("https"));
+var _lodash = require("lodash");
+var _url = _interopRequireDefault(require("url"));
+var _config = require("@verdaccio/config");
+var _index = _interopRequireDefault(require("../api/index"));
+var _constants2 = require("./constants");
+var _experiments = require("./experiments");
+var _logger = require("./logger");
+var _utils = require("./utils");
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+/**
+ * Trigger the server after configuration has been loaded.
+ * @param {Object} config
+ * @param {Object} cliArguments
+ * @param {String} configPath
+ * @param {String} pkgVersion
+ * @param {String} pkgName
+ * @deprecated use runServer instead
+ */
+function startVerdaccio(config, cliListen, configPath, pkgVersion, pkgName, callback) {
+  if ((0, _lodash.isObject)(config) === false) {
+    throw new Error(_constants2.API_ERROR.CONFIG_BAD_FORMAT);
+  }
+  (0, _utils.initLogger)(config);
+
+  // merge flags and experiments for backward compatibility
+  const flags = {
+    ...(config?.flags || {}),
+    ...(config?.experiments || {})
+  };
+  (0, _experiments.displayExperimentsInfoBox)(flags);
+  _logger.logger.warn('This is a deprecated method, please use runServer instead');
+  (0, _index.default)(config).then(app => {
+    const listen = cliListen ?? config?.listen;
+    const addr = (0, _config.getListenAddress)(listen, _logger.logger);
+    let webServer;
+    if (addr.proto === 'https') {
+      webServer = handleHTTPS(app, configPath, config);
+    } else {
+      // http
+      webServer = _http.default.createServer(app);
+    }
+    if (webServer && typeof config?.server?.keepAliveTimeout === 'number') {
+      // library definition for node is not up to date (doesn't contain recent 8.0 changes)
+      webServer.keepAliveTimeout = config.server.keepAliveTimeout * 1000;
+    }
+    unlinkAddressPath(addr);
+    callback(webServer, addr, pkgName, pkgVersion);
+  });
+}
+function unlinkAddressPath(addr) {
+  if (addr.path && _fs.default.existsSync(addr.path)) {
+    _fs.default.unlinkSync(addr.path);
+  }
+}
+function handleHTTPS(app, configPath, config) {
+  try {
+    let httpsOptions = {
+      secureOptions: _constants.default.SSL_OP_NO_SSLv2 | _constants.default.SSL_OP_NO_SSLv3 // disable insecure SSLv2 and SSLv3
+    };
+    const keyCertConfig = config.https;
+    const pfxConfig = config.https;
+    const missingKeyCert = !(keyCertConfig.key && keyCertConfig.cert);
+    (0, _console.debug)('missingKeyCert', missingKeyCert);
+    const missingPfx = !pfxConfig.pfx;
+    (0, _console.debug)('missingPfx', missingPfx);
+    if (missingKeyCert && missingPfx) {
+      (0, _console.debug)('No HTTPS configuration found');
+      (0, _utils.logHTTPSWarning)(configPath);
+      throw new Error('No HTTPS configuration found');
+    }
+    (0, _console.debug)('HTTPS configuration found');
+    if (pfxConfig.pfx) {
+      (0, _console.debug)('Using PFX configuration');
+      const {
+        pfx,
+        passphrase
+      } = pfxConfig;
+      httpsOptions = (0, _lodash.assign)(httpsOptions, {
+        pfx: _fs.default.readFileSync(pfx),
+        passphrase: passphrase || ''
+      });
+    } else {
+      (0, _console.debug)('Using Key/Cert configuration');
+      const {
+        key,
+        cert,
+        ca
+      } = keyCertConfig;
+      httpsOptions = (0, _lodash.assign)(httpsOptions, {
+        key: _fs.default.readFileSync(key),
+        cert: _fs.default.readFileSync(cert),
+        ...(ca && {
+          ca: _fs.default.readFileSync(ca)
+        })
+      });
+    }
+    return _https.default.createServer(httpsOptions, app);
+  } catch (err) {
+    // catch errors related to certificate loading
+    _logger.logger.fatal({
+      err: err
+    }, 'cannot create https server: @{err.message}');
+    process.exit(2);
+  }
+}
+/**
+ *
+ * @param webServer
+ * @param addr
+ * @param pkgName
+ * @param pkgVersion
+ * @deprecated use initServer instead
+ */
+function listenDefaultCallback(webServer, addr, pkgName, pkgVersion) {
+  const server = webServer.listen(addr.port || addr.path, addr.host, () => {
+    // send a message for tests
+    if ((0, _lodash.isFunction)(process.send)) {
+      process.send({
+        verdaccio_started: true
+      });
+    }
+  }).on('error', function (err) {
+    _logger.logger.fatal({
+      err: err
+    }, 'cannot create http server: @{err.message}');
+    process.exit(2);
+  });
+  function handleShutdownGracefully() {
+    _logger.logger.fatal('received shutdown signal - closing server gracefully...');
+    server.close(() => {
+      _logger.logger.info('server closed.');
+      process.exit(0);
+    });
+  }
+
+  // handle shutdown signals nicely when environment says so
+  if (process.env.VERDACCIO_HANDLE_KILL_SIGNALS === 'true') {
+    process.on('SIGINT', handleShutdownGracefully);
+    process.on('SIGTERM', handleShutdownGracefully);
+    process.on('SIGHUP', handleShutdownGracefully);
+  }
+  _logger.logger.warn({
+    addr: addr.path ? _url.default.format({
+      protocol: 'unix',
+      pathname: addr.path
+    }) : _url.default.format({
+      protocol: addr.proto,
+      hostname: addr.host,
+      port: addr.port,
+      pathname: '/'
+    }),
+    version: pkgName + '/' + pkgVersion
+  }, 'http address - @{addr} - @{version}');
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["_console","require","_constants","_interopRequireDefault","_fs","_http","_https","_lodash","_url","_config","_index","_constants2","_experiments","_logger","_utils","e","__esModule","default","startVerdaccio","config","cliListen","configPath","pkgVersion","pkgName","callback","isObject","Error","API_ERROR","CONFIG_BAD_FORMAT","initLogger","flags","experiments","displayExperimentsInfoBox","logger","warn","endPointAPI","then","app","listen","addr","getListenAddress","webServer","proto","handleHTTPS","http","createServer","server","keepAliveTimeout","unlinkAddressPath","path","fs","existsSync","unlinkSync","httpsOptions","secureOptions","constants","SSL_OP_NO_SSLv2","SSL_OP_NO_SSLv3","keyCertConfig","https","pfxConfig","missingKeyCert","key","cert","debug","missingPfx","pfx","logHTTPSWarning","passphrase","assign","readFileSync","ca","err","fatal","process","exit","listenDefaultCallback","port","host","isFunction","send","verdaccio_started","on","handleShutdownGracefully","close","info","env","VERDACCIO_HANDLE_KILL_SIGNALS","URL","format","protocol","pathname","hostname","version"],"sources":["../../src/lib/bootstrap.ts"],"sourcesContent":["import { debug } from 'console';\nimport constants from 'constants';\nimport express from 'express';\nimport { Application } from 'express';\nimport fs from 'fs';\nimport http from 'http';\nimport https from 'https';\nimport { assign, isFunction, isObject } from 'lodash';\nimport URL from 'url';\n\nimport { getListenAddress } from '@verdaccio/config';\nimport { Callback, ConfigYaml, HttpsConfKeyCert, HttpsConfPfx } from '@verdaccio/types';\n\nimport endPointAPI from '../api/index';\nimport { API_ERROR } from './constants';\nimport { displayExperimentsInfoBox } from './experiments';\nimport { logger } from './logger';\nimport { initLogger, logHTTPSWarning } from './utils';\n\n/**\n * Trigger the server after configuration has been loaded.\n * @param {Object} config\n * @param {Object} cliArguments\n * @param {String} configPath\n * @param {String} pkgVersion\n * @param {String} pkgName\n * @deprecated use runServer instead\n */\nfunction startVerdaccio(\n  config: ConfigYaml,\n  cliListen: string,\n  configPath: string,\n  pkgVersion: string,\n  pkgName: string,\n  callback: Callback\n): void {\n  if (isObject(config) === false) {\n    throw new Error(API_ERROR.CONFIG_BAD_FORMAT);\n  }\n\n  initLogger(config);\n\n  // merge flags and experiments for backward compatibility\n  const flags = {\n    ...(config?.flags || {}),\n    ...(config?.experiments || {}),\n  };\n  displayExperimentsInfoBox(flags);\n  logger.warn('This is a deprecated method, please use runServer instead');\n\n  endPointAPI(config).then((app): void => {\n    const listen = cliListen ?? config?.listen;\n    const addr = getListenAddress(listen, logger);\n    let webServer;\n    if (addr.proto === 'https') {\n      webServer = handleHTTPS(app, configPath, config);\n    } else {\n      // http\n      webServer = http.createServer(app);\n    }\n    if (webServer && typeof config?.server?.keepAliveTimeout === 'number') {\n      // library definition for node is not up to date (doesn't contain recent 8.0 changes)\n      webServer.keepAliveTimeout = config.server.keepAliveTimeout * 1000;\n    }\n    unlinkAddressPath(addr);\n    callback(webServer, addr, pkgName, pkgVersion);\n  });\n}\n\nfunction unlinkAddressPath(addr) {\n  if (addr.path && fs.existsSync(addr.path)) {\n    fs.unlinkSync(addr.path);\n  }\n}\n\nfunction handleHTTPS(\n  app: express.Application,\n  configPath: string,\n  config: ConfigYaml\n): https.Server {\n  try {\n    let httpsOptions = {\n      secureOptions: constants.SSL_OP_NO_SSLv2 | constants.SSL_OP_NO_SSLv3, // disable insecure SSLv2 and SSLv3\n    };\n    const keyCertConfig = config.https as HttpsConfKeyCert;\n    const pfxConfig = config.https as HttpsConfPfx;\n\n    const missingKeyCert = !(keyCertConfig.key && keyCertConfig.cert);\n    debug('missingKeyCert', missingKeyCert);\n    const missingPfx = !pfxConfig.pfx;\n    debug('missingPfx', missingPfx);\n\n    if (missingKeyCert && missingPfx) {\n      debug('No HTTPS configuration found');\n      logHTTPSWarning(configPath);\n      throw new Error('No HTTPS configuration found');\n    }\n\n    debug('HTTPS configuration found');\n    if (pfxConfig.pfx) {\n      debug('Using PFX configuration');\n      const { pfx, passphrase } = pfxConfig;\n      httpsOptions = assign(httpsOptions, {\n        pfx: fs.readFileSync(pfx),\n        passphrase: passphrase || '',\n      });\n    } else {\n      debug('Using Key/Cert configuration');\n      const { key, cert, ca } = keyCertConfig;\n      httpsOptions = assign(httpsOptions, {\n        key: fs.readFileSync(key),\n        cert: fs.readFileSync(cert),\n        ...(ca && {\n          ca: fs.readFileSync(ca),\n        }),\n      });\n    }\n    return https.createServer(httpsOptions, app);\n  } catch (err: any) {\n    // catch errors related to certificate loading\n    logger.fatal({ err: err }, 'cannot create https server: @{err.message}');\n    process.exit(2);\n  }\n}\n/**\n *\n * @param webServer\n * @param addr\n * @param pkgName\n * @param pkgVersion\n * @deprecated use initServer instead\n */\nfunction listenDefaultCallback(\n  webServer: Application,\n  addr: any,\n  pkgName: string,\n  pkgVersion: string\n): void {\n  const server = webServer\n    .listen(addr.port || addr.path, addr.host, (): void => {\n      // send a message for tests\n      if (isFunction(process.send)) {\n        process.send({\n          verdaccio_started: true,\n        });\n      }\n    })\n    .on('error', function (err): void {\n      logger.fatal({ err: err }, 'cannot create http server: @{err.message}');\n      process.exit(2);\n    });\n\n  function handleShutdownGracefully() {\n    logger.fatal('received shutdown signal - closing server gracefully...');\n    server.close(() => {\n      logger.info('server closed.');\n      process.exit(0);\n    });\n  }\n\n  // handle shutdown signals nicely when environment says so\n  if (process.env.VERDACCIO_HANDLE_KILL_SIGNALS === 'true') {\n    process.on('SIGINT', handleShutdownGracefully);\n    process.on('SIGTERM', handleShutdownGracefully);\n    process.on('SIGHUP', handleShutdownGracefully);\n  }\n\n  logger.warn(\n    {\n      addr: addr.path\n        ? URL.format({\n            protocol: 'unix',\n            pathname: addr.path,\n          })\n        : URL.format({\n            protocol: addr.proto,\n            hostname: addr.host,\n            port: addr.port,\n            pathname: '/',\n          }),\n      version: pkgName + '/' + pkgVersion,\n    },\n    'http address - @{addr} - @{version}'\n  );\n}\n\nexport { startVerdaccio, listenDefaultCallback };\n"],"mappings":"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","ignoreList":[]}

package/build/lib/cli/cli.js

@@ -0,0 +1,26 @@
+"use strict";
+
+var _clipanion = require("clipanion");
+var _info = require("./commands/info");
+var _init = require("./commands/init");
+var _version = require("./commands/version");
+var _utils = require("./utils");
+const pkgVersion = "6.3.2" || 'dev';
+if (process.getuid && process.getuid() === 0) {
+  process.emitWarning(`Verdaccio doesn't need superuser privileges. don't run it under root`);
+}
+if (!(0, _utils.isVersionValid)(process.version)) {
+  throw new Error(`Verdaccio requires at least Node.js v${_utils.MIN_NODE_VERSION} or higher and you have installed ${process.version}, 
+    please upgrade your Node.js distribution`);
+}
+const [node, app, ...args] = process.argv;
+const cli = new _clipanion.Cli({
+  binaryLabel: `verdaccio`,
+  binaryName: `${node} ${app}`,
+  binaryVersion: pkgVersion
+});
+cli.register(_info.InfoCommand);
+cli.register(_init.InitCommand);
+cli.register(_version.VersionCommand);
+cli.runExit(args, _clipanion.Cli.defaultContext);
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJuYW1lcyI6WyJfY2xpcGFuaW9uIiwicmVxdWlyZSIsIl9pbmZvIiwiX2luaXQiLCJfdmVyc2lvbiIsIl91dGlscyIsInBrZ1ZlcnNpb24iLCJwcm9jZXNzIiwiZ2V0dWlkIiwiZW1pdFdhcm5pbmciLCJpc1ZlcnNpb25WYWxpZCIsInZlcnNpb24iLCJFcnJvciIsIk1JTl9OT0RFX1ZFUlNJT04iLCJub2RlIiwiYXBwIiwiYXJncyIsImFyZ3YiLCJjbGkiLCJDbGkiLCJiaW5hcnlMYWJlbCIsImJpbmFyeU5hbWUiLCJiaW5hcnlWZXJzaW9uIiwicmVnaXN0ZXIiLCJJbmZvQ29tbWFuZCIsIkluaXRDb21tYW5kIiwiVmVyc2lvbkNvbW1hbmQiLCJydW5FeGl0IiwiZGVmYXVsdENvbnRleHQiXSwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvbGliL2NsaS9jbGkudHMiXSwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgQ2xpIH0gZnJvbSAnY2xpcGFuaW9uJztcblxuaW1wb3J0IHsgSW5mb0NvbW1hbmQgfSBmcm9tICcuL2NvbW1hbmRzL2luZm8nO1xuaW1wb3J0IHsgSW5pdENvbW1hbmQgfSBmcm9tICcuL2NvbW1hbmRzL2luaXQnO1xuaW1wb3J0IHsgVmVyc2lvbkNvbW1hbmQgfSBmcm9tICcuL2NvbW1hbmRzL3ZlcnNpb24nO1xuaW1wb3J0IHsgTUlOX05PREVfVkVSU0lPTiwgaXNWZXJzaW9uVmFsaWQgfSBmcm9tICcuL3V0aWxzJztcblxuY29uc3QgcGtnVmVyc2lvbiA9IHByb2Nlc3MuZW52LlBBQ0tBR0VfVkVSU0lPTiB8fCAnZGV2JztcblxuaWYgKHByb2Nlc3MuZ2V0dWlkICYmIHByb2Nlc3MuZ2V0dWlkKCkgPT09IDApIHtcbiAgcHJvY2Vzcy5lbWl0V2FybmluZyhgVmVyZGFjY2lvIGRvZXNuJ3QgbmVlZCBzdXBlcnVzZXIgcHJpdmlsZWdlcy4gZG9uJ3QgcnVuIGl0IHVuZGVyIHJvb3RgKTtcbn1cblxuaWYgKCFpc1ZlcnNpb25WYWxpZChwcm9jZXNzLnZlcnNpb24pKSB7XG4gIHRocm93IG5ldyBFcnJvcihcbiAgICBgVmVyZGFjY2lvIHJlcXVpcmVzIGF0IGxlYXN0IE5vZGUuanMgdiR7TUlOX05PREVfVkVSU0lPTn0gb3IgaGlnaGVyIGFuZCB5b3UgaGF2ZSBpbnN0YWxsZWQgJHtwcm9jZXNzLnZlcnNpb259LCBcbiAgICBwbGVhc2UgdXBncmFkZSB5b3VyIE5vZGUuanMgZGlzdHJpYnV0aW9uYFxuICApO1xufVxuXG5jb25zdCBbbm9kZSwgYXBwLCAuLi5hcmdzXSA9IHByb2Nlc3MuYXJndjtcblxuY29uc3QgY2xpID0gbmV3IENsaSh7XG4gIGJpbmFyeUxhYmVsOiBgdmVyZGFjY2lvYCxcbiAgYmluYXJ5TmFtZTogYCR7bm9kZX0gJHthcHB9YCxcbiAgYmluYXJ5VmVyc2lvbjogcGtnVmVyc2lvbixcbn0pO1xuXG5jbGkucmVnaXN0ZXIoSW5mb0NvbW1hbmQpO1xuY2xpLnJlZ2lzdGVyKEluaXRDb21tYW5kKTtcbmNsaS5yZWdpc3RlcihWZXJzaW9uQ29tbWFuZCk7XG5jbGkucnVuRXhpdChhcmdzLCBDbGkuZGVmYXVsdENvbnRleHQpO1xuIl0sIm1hcHBpbmdzIjoiOztBQUFBLElBQUFBLFVBQUEsR0FBQUMsT0FBQTtBQUVBLElBQUFDLEtBQUEsR0FBQUQsT0FBQTtBQUNBLElBQUFFLEtBQUEsR0FBQUYsT0FBQTtBQUNBLElBQUFHLFFBQUEsR0FBQUgsT0FBQTtBQUNBLElBQUFJLE1BQUEsR0FBQUosT0FBQTtBQUVBLE1BQU1LLFVBQVUsR0FBRyxXQUErQixLQUFLO0FBRXZELElBQUlDLE9BQU8sQ0FBQ0MsTUFBTSxJQUFJRCxPQUFPLENBQUNDLE1BQU0sQ0FBQyxDQUFDLEtBQUssQ0FBQyxFQUFFO0VBQzVDRCxPQUFPLENBQUNFLFdBQVcsQ0FBQyxzRUFBc0UsQ0FBQztBQUM3RjtBQUVBLElBQUksQ0FBQyxJQUFBQyxxQkFBYyxFQUFDSCxPQUFPLENBQUNJLE9BQU8sQ0FBQyxFQUFFO0VBQ3BDLE1BQU0sSUFBSUMsS0FBSyxDQUNiLHdDQUF3Q0MsdUJBQWdCLHFDQUFxQ04sT0FBTyxDQUFDSSxPQUFPO0FBQ2hILDZDQUNFLENBQUM7QUFDSDtBQUVBLE1BQU0sQ0FBQ0csSUFBSSxFQUFFQyxHQUFHLEVBQUUsR0FBR0MsSUFBSSxDQUFDLEdBQUdULE9BQU8sQ0FBQ1UsSUFBSTtBQUV6QyxNQUFNQyxHQUFHLEdBQUcsSUFBSUMsY0FBRyxDQUFDO0VBQ2xCQyxXQUFXLEVBQUUsV0FBVztFQUN4QkMsVUFBVSxFQUFFLEdBQUdQLElBQUksSUFBSUMsR0FBRyxFQUFFO0VBQzVCTyxhQUFhLEVBQUVoQjtBQUNqQixDQUFDLENBQUM7QUFFRlksR0FBRyxDQUFDSyxRQUFRLENBQUNDLGlCQUFXLENBQUM7QUFDekJOLEdBQUcsQ0FBQ0ssUUFBUSxDQUFDRSxpQkFBVyxDQUFDO0FBQ3pCUCxHQUFHLENBQUNLLFFBQVEsQ0FBQ0csdUJBQWMsQ0FBQztBQUM1QlIsR0FBRyxDQUFDUyxPQUFPLENBQUNYLElBQUksRUFBRUcsY0FBRyxDQUFDUyxjQUFjLENBQUMiLCJpZ25vcmVMaXN0IjpbXX0=

package/build/lib/cli/commands/info.js

@@ -0,0 +1,26 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.InfoCommand = void 0;
+var _clipanion = require("clipanion");
+var _envinfo = _interopRequireDefault(require("envinfo"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+class InfoCommand extends _clipanion.Command {
+  static paths = [[`--info`], [`-i`]];
+  async execute() {
+    this.context.stdout.write('\nEnvironment Info:');
+    const data = await _envinfo.default.run({
+      System: ['OS', 'CPU'],
+      Binaries: ['node', 'yarn', 'npm', 'pnpm'],
+      Virtualization: ['Docker'],
+      Browsers: ['Chrome', 'Edge', 'Firefox', 'Safari'],
+      npmGlobalPackages: ['verdaccio']
+    });
+    this.context.stdout.write(data);
+    process.exit(0);
+  }
+}
+exports.InfoCommand = InfoCommand;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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