@verdaccio/canary 6.3.2-canary.404363f

package/build/lib/uplink-util.js

@@ -0,0 +1,36 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.setupUpLinks = setupUpLinks;
+exports.updateVersionsHiddenUpLink = updateVersionsHiddenUpLink;
+var _upStorage = _interopRequireDefault(require("./up-storage"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+/**
+ * Set up the Up Storage for each link.
+ */
+function setupUpLinks(config) {
+  const uplinks = {};
+  for (const uplinkName in config.uplinks) {
+    if (Object.prototype.hasOwnProperty.call(config.uplinks, uplinkName)) {
+      // instance for each up-link definition
+      const proxy = new _upStorage.default(config.uplinks[uplinkName], config);
+      proxy.upname = uplinkName;
+      uplinks[uplinkName] = proxy;
+    }
+  }
+  return uplinks;
+}
+function updateVersionsHiddenUpLink(versions, upLink) {
+  for (const i in versions) {
+    if (Object.prototype.hasOwnProperty.call(versions, i)) {
+      const version = versions[i];
+
+      // holds a "hidden" value to be used by the package storage.
+
+      version[Symbol.for('__verdaccio_uplink')] = upLink.upname;
+    }
+  }
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/build/lib/utils.js

@@ -0,0 +1,265 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.ErrorCode = void 0;
+exports.addScope = addScope;
+Object.defineProperty(exports, "buildToken", {
+  enumerable: true,
+  get: function () {
+    return _utils.buildToken;
+  }
+});
+exports.deleteProperties = deleteProperties;
+exports.encodeScopedUri = encodeScopedUri;
+exports.getVersion = getVersion;
+exports.hasDiffOneKey = hasDiffOneKey;
+exports.hasLogin = hasLogin;
+exports.initLogger = initLogger;
+exports.isObject = void 0;
+exports.isObjectOrArray = isObjectOrArray;
+exports.isRelatedToDeprecation = isRelatedToDeprecation;
+exports.isVersionValid = isVersionValid;
+exports.logHTTPSWarning = logHTTPSWarning;
+exports.normalizeDistTags = normalizeDistTags;
+Object.defineProperty(exports, "parseConfigFile", {
+  enumerable: true,
+  get: function () {
+    return _config.parseConfigFile;
+  }
+});
+exports.parseInterval = parseInterval;
+exports.parseReadme = parseReadme;
+exports.resolveConfigPath = void 0;
+exports.sortByName = sortByName;
+exports.tagVersion = tagVersion;
+var _debug = _interopRequireDefault(require("debug"));
+var _lodash = _interopRequireDefault(require("lodash"));
+var _nodePath = _interopRequireDefault(require("node:path"));
+var _semver = _interopRequireDefault(require("semver"));
+var _config = require("@verdaccio/config");
+var _core = require("@verdaccio/core");
+var _utils = require("@verdaccio/utils");
+var _constants = require("./constants");
+var _logger = require("./logger");
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+const debug = (0, _debug.default)('verdaccio:lib:utils');
+const {
+  getBadData,
+  getBadRequest,
+  getCode,
+  getConflict,
+  getForbidden,
+  getInternalError,
+  getNotFound,
+  getServiceUnavailable,
+  getUnauthorized
+} = _core.errorUtils;
+function initLogger(logConfig) {
+  if (logConfig.logs) {
+    logConfig.log = logConfig.logs;
+    _core.warningUtils.emit(_core.warningUtils.Codes.VERWAR002);
+  }
+  debug('initializing logger with config: %o', logConfig.log);
+  (0, _logger.setup)(logConfig.log);
+}
+function addScope(scope, packageName) {
+  return `@${scope}/${packageName}`;
+}
+
+/**
+ * Check whether an element is an Object
+ * @param {*} obj the element
+ * @return {Boolean}
+ */
+const isObject = exports.isObject = _core.validationUtils.isObject;
+
+/**
+ * @deprecated not used un v6
+ */
+function isObjectOrArray(obj) {
+  return _lodash.default.isObject(obj) && _lodash.default.isNull(obj) === false;
+}
+function tagVersion(data, version, tag) {
+  if (tag && data[_constants.DIST_TAGS][tag] !== version && _semver.default.parse(version, true)) {
+    // valid version - store
+    data[_constants.DIST_TAGS][tag] = version;
+    return true;
+  }
+  return false;
+}
+
+/**
+ * Gets version from a package object taking into account semver weirdness.
+ * @return {String} return the semantic version of a package
+ */
+function getVersion(pkg, version) {
+  // this condition must allow cast
+  if (_lodash.default.isNil(pkg.versions[version]) === false) {
+    return pkg.versions[version];
+  }
+  try {
+    version = _semver.default.parse(version, true);
+    for (const versionItem in pkg.versions) {
+      if (version.compare(_semver.default.parse(versionItem, true)) === 0) {
+        return pkg.versions[versionItem];
+      }
+    }
+  } catch {
+    return undefined;
+  }
+}
+
+/**
+ * Flatten arrays of tags.
+ * @param {*} data
+ */
+function normalizeDistTags(pkg) {
+  let sorted;
+  if (!pkg[_constants.DIST_TAGS].latest) {
+    // overwrite latest with highest known version based on semver sort
+    sorted = _core.pkgUtils.semverSort(Object.keys(pkg.versions));
+    if (sorted && sorted.length) {
+      pkg[_constants.DIST_TAGS].latest = sorted.pop();
+    }
+  }
+  for (const tag in pkg[_constants.DIST_TAGS]) {
+    if (_lodash.default.isArray(pkg[_constants.DIST_TAGS][tag])) {
+      if (pkg[_constants.DIST_TAGS][tag].length) {
+        // sort array
+        // FIXME: this is clearly wrong, we need to research why this is like this.
+        sorted = _core.pkgUtils.semverSort(pkg[_constants.DIST_TAGS][tag]);
+        if (sorted.length) {
+          // use highest version based on semver sort
+          pkg[_constants.DIST_TAGS][tag] = sorted.pop();
+        }
+      } else {
+        delete pkg[_constants.DIST_TAGS][tag];
+      }
+    } else if (_lodash.default.isString(pkg[_constants.DIST_TAGS][tag])) {
+      if (!_semver.default.parse(pkg[_constants.DIST_TAGS][tag], true)) {
+        // if the version is invalid, delete the dist-tag entry
+        delete pkg[_constants.DIST_TAGS][tag];
+      }
+    }
+  }
+}
+const parseIntervalTable = {
+  '': 1000,
+  ms: 1,
+  s: 1000,
+  m: 60 * 1000,
+  h: 60 * 60 * 1000,
+  d: 86400000,
+  w: 7 * 86400000,
+  M: 30 * 86400000,
+  y: 365 * 86400000
+};
+
+/**
+ * Parse an internal string to number
+ * @param {*} interval
+ * @return {Number}
+ */
+function parseInterval(interval) {
+  if (typeof interval === 'number') {
+    return interval * 1000;
+  }
+  let result = 0;
+  let last_suffix = Infinity;
+  interval.split(/\s+/).forEach(function (x) {
+    if (!x) {
+      return;
+    }
+    const m = x.match(/^((0|[1-9][0-9]*)(\.[0-9]+)?)(ms|s|m|h|d|w|M|y|)$/);
+    if (!m || parseIntervalTable[m[4]] >= last_suffix || m[4] === '' && last_suffix !== Infinity) {
+      throw Error('invalid interval: ' + interval);
+    }
+    last_suffix = parseIntervalTable[m[4]];
+    result += Number(m[1]) * parseIntervalTable[m[4]];
+  });
+  return result;
+}
+const ErrorCode = exports.ErrorCode = {
+  getConflict,
+  getBadData,
+  getBadRequest,
+  getInternalError,
+  getUnauthorized,
+  getForbidden,
+  getServiceUnavailable,
+  getNotFound,
+  getCode
+};
+function sortByName(packages, orderAscending = true) {
+  return packages.slice().sort(function (a, b) {
+    const comparatorNames = a.name.toLowerCase() < b.name.toLowerCase();
+    return orderAscending ? comparatorNames ? -1 : 1 : comparatorNames ? 1 : -1;
+  });
+}
+function deleteProperties(propertiesToDelete, objectItem) {
+  _lodash.default.forEach(propertiesToDelete, property => {
+    delete objectItem[property];
+  });
+  return objectItem;
+}
+
+/**
+ * parse package readme - markdown/ascii
+ * @param {String} packageName name of package
+ * @param {String} readme package readme
+
+ * @return {String} converted html template
+ */
+// TODO: rename, does not parse anymore
+function parseReadme(packageName, readme) {
+  if (_lodash.default.isEmpty(readme) === false) {
+    return readme;
+  }
+
+  // logs readme not found error
+  _logger.logger.info({
+    packageName
+  }, '@{packageName}: No readme found');
+  return 'ERROR: No README data found!';
+}
+function encodeScopedUri(packageName) {
+  return packageName.replace(/\//g, '%2f');
+}
+function hasDiffOneKey(versions) {
+  return Object.keys(versions).length !== 1;
+}
+function isVersionValid(packageMeta, packageVersion) {
+  const hasVersion = typeof packageVersion !== 'undefined';
+  if (!hasVersion) {
+    return false;
+  }
+  const hasMatchVersion = Object.keys(packageMeta.versions).includes(packageVersion);
+  return hasMatchVersion;
+}
+function isRelatedToDeprecation(pkgInfo) {
+  const {
+    versions
+  } = pkgInfo;
+  for (const version in versions) {
+    if (Object.prototype.hasOwnProperty.call(versions[version], 'deprecated')) {
+      return true;
+    }
+  }
+  return false;
+}
+const resolveConfigPath = function (storageLocation, file) {
+  return _nodePath.default.resolve(_nodePath.default.dirname(storageLocation), file);
+};
+exports.resolveConfigPath = resolveConfigPath;
+function logHTTPSWarning(storageLocation) {
+  _logger.logger.fatal(['You have enabled HTTPS and need to specify either ', '    "https.key" and "https.cert" or ', '    "https.pfx" and optionally "https.passphrase" ', 'to run https server', '',
+  // commands are borrowed from node.js docs
+  'To quickly create self-signed certificate, use:', ' $ openssl genrsa -out ' + resolveConfigPath(storageLocation, _constants.keyPem) + ' 2048', ' $ openssl req -new -sha256 -key ' + resolveConfigPath(storageLocation, _constants.keyPem) + ' -out ' + resolveConfigPath(storageLocation, _constants.csrPem), ' $ openssl x509 -req -in ' + resolveConfigPath(storageLocation, _constants.csrPem) + ' -signkey ' + resolveConfigPath(storageLocation, _constants.keyPem) + ' -out ' + resolveConfigPath(storageLocation, _constants.certPem), '', 'And then add to config file (' + storageLocation + '):', '  https:', `    key: ${resolveConfigPath(storageLocation, _constants.keyPem)}`, `    cert: ${resolveConfigPath(storageLocation, _constants.certPem)}`].join('\n'));
+  process.exit(2);
+}
+function hasLogin(config) {
+  return _lodash.default.isNil(config?.web?.login) || config?.web?.login === true;
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["_debug","_interopRequireDefault","require","_lodash","_nodePath","_semver","_config","_core","_utils","_constants","_logger","e","__esModule","default","debug","createDebug","getBadData","getBadRequest","getCode","getConflict","getForbidden","getInternalError","getNotFound","getServiceUnavailable","getUnauthorized","errorUtils","initLogger","logConfig","logs","log","warningUtils","emit","Codes","VERWAR002","setup","addScope","scope","packageName","isObject","exports","validationUtils","isObjectOrArray","obj","_","isNull","tagVersion","data","version","tag","DIST_TAGS","semver","parse","getVersion","pkg","isNil","versions","versionItem","compare","undefined","normalizeDistTags","sorted","latest","pkgUtils","semverSort","Object","keys","length","pop","isArray","isString","parseIntervalTable","ms","s","m","h","d","w","M","y","parseInterval","interval","result","last_suffix","Infinity","split","forEach","x","match","Error","Number","ErrorCode","sortByName","packages","orderAscending","slice","sort","a","b","comparatorNames","name","toLowerCase","deleteProperties","propertiesToDelete","objectItem","property","parseReadme","readme","isEmpty","logger","info","encodeScopedUri","replace","hasDiffOneKey","isVersionValid","packageMeta","packageVersion","hasVersion","hasMatchVersion","includes","isRelatedToDeprecation","pkgInfo","prototype","hasOwnProperty","call","resolveConfigPath","storageLocation","file","path","resolve","dirname","logHTTPSWarning","fatal","keyPem","csrPem","certPem","join","process","exit","hasLogin","config","web","login"],"sources":["../../src/lib/utils.ts"],"sourcesContent":["import createDebug from 'debug';\nimport _ from 'lodash';\nimport path from 'node:path';\nimport semver from 'semver';\n\nimport { parseConfigFile } from '@verdaccio/config';\nimport { errorUtils, pkgUtils, validationUtils, warningUtils } from '@verdaccio/core';\nimport { ConfigYaml, LoggerConfigItem, StringValue } from '@verdaccio/types';\nimport { Config, Manifest, Version } from '@verdaccio/types';\nimport { buildToken as buildTokenUtil } from '@verdaccio/utils';\n\nimport { DIST_TAGS, certPem, csrPem, keyPem } from './constants';\nimport { logger, setup } from './logger';\n\nconst debug = createDebug('verdaccio:lib:utils');\n\nconst {\n  getBadData,\n  getBadRequest,\n  getCode,\n  getConflict,\n  getForbidden,\n  getInternalError,\n  getNotFound,\n  getServiceUnavailable,\n  getUnauthorized,\n} = errorUtils;\n\nexport function initLogger(logConfig: ConfigYaml) {\n  if (logConfig.logs) {\n    logConfig.log = logConfig.logs;\n    warningUtils.emit(warningUtils.Codes.VERWAR002);\n  }\n  debug('initializing logger with config: %o', logConfig.log);\n  setup(logConfig.log as LoggerConfigItem);\n}\n\nexport function addScope(scope: string, packageName: string): string {\n  return `@${scope}/${packageName}`;\n}\n\n/**\n * Check whether an element is an Object\n * @param {*} obj the element\n * @return {Boolean}\n */\nexport const isObject = validationUtils.isObject;\n\n/**\n * @deprecated not used un v6\n */\nexport function isObjectOrArray(obj: any): boolean {\n  return _.isObject(obj) && _.isNull(obj) === false;\n}\n\nexport function tagVersion(data: Manifest, version: string, tag: StringValue): boolean {\n  if (tag && data[DIST_TAGS][tag] !== version && semver.parse(version, true)) {\n    // valid version - store\n    data[DIST_TAGS][tag] = version;\n    return true;\n  }\n  return false;\n}\n\n/**\n * Gets version from a package object taking into account semver weirdness.\n * @return {String} return the semantic version of a package\n */\nexport function getVersion(pkg: Manifest, version: any): Version | void {\n  // this condition must allow cast\n  if (_.isNil(pkg.versions[version]) === false) {\n    return pkg.versions[version];\n  }\n\n  try {\n    version = semver.parse(version, true);\n    for (const versionItem in pkg.versions) {\n      if (version.compare(semver.parse(versionItem, true)) === 0) {\n        return pkg.versions[versionItem];\n      }\n    }\n  } catch {\n    return undefined;\n  }\n}\n\n/**\n * Flatten arrays of tags.\n * @param {*} data\n */\nexport function normalizeDistTags(pkg: Manifest): void {\n  let sorted;\n  if (!pkg[DIST_TAGS].latest) {\n    // overwrite latest with highest known version based on semver sort\n    sorted = pkgUtils.semverSort(Object.keys(pkg.versions));\n    if (sorted && sorted.length) {\n      pkg[DIST_TAGS].latest = sorted.pop();\n    }\n  }\n\n  for (const tag in pkg[DIST_TAGS]) {\n    if (_.isArray(pkg[DIST_TAGS][tag])) {\n      if (pkg[DIST_TAGS][tag].length) {\n        // sort array\n        // FIXME: this is clearly wrong, we need to research why this is like this.\n        sorted = pkgUtils.semverSort(pkg[DIST_TAGS][tag]);\n        if (sorted.length) {\n          // use highest version based on semver sort\n          pkg[DIST_TAGS][tag] = sorted.pop();\n        }\n      } else {\n        delete pkg[DIST_TAGS][tag];\n      }\n    } else if (_.isString(pkg[DIST_TAGS][tag])) {\n      if (!semver.parse(pkg[DIST_TAGS][tag], true)) {\n        // if the version is invalid, delete the dist-tag entry\n        delete pkg[DIST_TAGS][tag];\n      }\n    }\n  }\n}\n\nconst parseIntervalTable = {\n  '': 1000,\n  ms: 1,\n  s: 1000,\n  m: 60 * 1000,\n  h: 60 * 60 * 1000,\n  d: 86400000,\n  w: 7 * 86400000,\n  M: 30 * 86400000,\n  y: 365 * 86400000,\n};\n\n/**\n * Parse an internal string to number\n * @param {*} interval\n * @return {Number}\n */\nexport function parseInterval(interval: any): number {\n  if (typeof interval === 'number') {\n    return interval * 1000;\n  }\n  let result = 0;\n  let last_suffix = Infinity;\n  interval.split(/\\s+/).forEach(function (x): void {\n    if (!x) {\n      return;\n    }\n    const m = x.match(/^((0|[1-9][0-9]*)(\\.[0-9]+)?)(ms|s|m|h|d|w|M|y|)$/);\n    if (\n      !m ||\n      parseIntervalTable[m[4]] >= last_suffix ||\n      (m[4] === '' && last_suffix !== Infinity)\n    ) {\n      throw Error('invalid interval: ' + interval);\n    }\n    last_suffix = parseIntervalTable[m[4]];\n    result += Number(m[1]) * parseIntervalTable[m[4]];\n  });\n  return result;\n}\n\nexport const ErrorCode = {\n  getConflict,\n  getBadData,\n  getBadRequest,\n  getInternalError,\n  getUnauthorized,\n  getForbidden,\n  getServiceUnavailable,\n  getNotFound,\n  getCode,\n};\n\nexport function sortByName(packages: any[], orderAscending: boolean | void = true): string[] {\n  return packages.slice().sort(function (a, b): number {\n    const comparatorNames = a.name.toLowerCase() < b.name.toLowerCase();\n\n    return orderAscending ? (comparatorNames ? -1 : 1) : comparatorNames ? 1 : -1;\n  });\n}\n\nexport function deleteProperties(propertiesToDelete: string[], objectItem: any): any {\n  _.forEach(propertiesToDelete, (property): any => {\n    delete objectItem[property];\n  });\n\n  return objectItem;\n}\n\n/**\n * parse package readme - markdown/ascii\n * @param {String} packageName name of package\n * @param {String} readme package readme\n\n * @return {String} converted html template\n */\n// TODO: rename, does not parse anymore\nexport function parseReadme(packageName: string, readme: string): string | void {\n  if (_.isEmpty(readme) === false) {\n    return readme;\n  }\n\n  // logs readme not found error\n  logger.info({ packageName }, '@{packageName}: No readme found');\n\n  return 'ERROR: No README data found!';\n}\n\nexport function encodeScopedUri(packageName): string {\n  return packageName.replace(/\\//g, '%2f');\n}\n\nexport function hasDiffOneKey(versions): boolean {\n  return Object.keys(versions).length !== 1;\n}\n\nexport function isVersionValid(packageMeta, packageVersion): boolean {\n  const hasVersion = typeof packageVersion !== 'undefined';\n  if (!hasVersion) {\n    return false;\n  }\n\n  const hasMatchVersion = Object.keys(packageMeta.versions).includes(packageVersion);\n  return hasMatchVersion;\n}\n\nexport function isRelatedToDeprecation(pkgInfo: Manifest): boolean {\n  const { versions } = pkgInfo;\n  for (const version in versions) {\n    if (Object.prototype.hasOwnProperty.call(versions[version], 'deprecated')) {\n      return true;\n    }\n  }\n  return false;\n}\n\nexport const resolveConfigPath = function (storageLocation: string, file: string) {\n  return path.resolve(path.dirname(storageLocation), file);\n};\n\nexport function logHTTPSWarning(storageLocation) {\n  logger.fatal(\n    [\n      'You have enabled HTTPS and need to specify either ',\n      '    \"https.key\" and \"https.cert\" or ',\n      '    \"https.pfx\" and optionally \"https.passphrase\" ',\n      'to run https server',\n      '',\n      // commands are borrowed from node.js docs\n      'To quickly create self-signed certificate, use:',\n      ' $ openssl genrsa -out ' + resolveConfigPath(storageLocation, keyPem) + ' 2048',\n      ' $ openssl req -new -sha256 -key ' +\n        resolveConfigPath(storageLocation, keyPem) +\n        ' -out ' +\n        resolveConfigPath(storageLocation, csrPem),\n      ' $ openssl x509 -req -in ' +\n        resolveConfigPath(storageLocation, csrPem) +\n        ' -signkey ' +\n        resolveConfigPath(storageLocation, keyPem) +\n        ' -out ' +\n        resolveConfigPath(storageLocation, certPem),\n      '',\n      'And then add to config file (' + storageLocation + '):',\n      '  https:',\n      `    key: ${resolveConfigPath(storageLocation, keyPem)}`,\n      `    cert: ${resolveConfigPath(storageLocation, certPem)}`,\n    ].join('\\n')\n  );\n  process.exit(2);\n}\n\nexport function hasLogin(config: Config) {\n  return _.isNil(config?.web?.login) || config?.web?.login === true;\n}\n\nexport { buildTokenUtil as buildToken, parseConfigFile };\n"],"mappings":"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","ignoreList":[]}

package/index.js

@@ -0,0 +1 @@
+export { default as startVerdaccio } from './build/index';

package/package.json

@@ -0,0 +1,156 @@
+{
+  "name": "@verdaccio/canary",
+  "version": "6.3.2-canary.404363f",
+  "description": "A lightweight private npm proxy registry",
+  "author": {
+    "name": "Verdaccio Maintainers",
+    "email": "verdaccio.npm@gmail.com"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git://github.com/verdaccio/verdaccio"
+  },
+  "homepage": "https://verdaccio.org",
+  "main": "build/index.js",
+  "types": "build/index.d.ts",
+  "bin": {
+    "verdaccio-canary": "./bin/verdaccio-canary"
+  },
+  "funding": {
+    "type": "opencollective",
+    "url": "https://opencollective.com/verdaccio"
+  },
+  "dependencies": {
+    "@cypress/request": "3.0.10",
+    "@verdaccio/auth": "8.0.0-next-8.36",
+    "@verdaccio/config": "8.0.0-next-8.36",
+    "@verdaccio/core": "8.0.0-next-8.36",
+    "@verdaccio/hooks": "8.0.0-next-8.36",
+    "@verdaccio/loaders": "8.0.0-next-8.26",
+    "@verdaccio/local-storage-legacy": "11.1.1",
+    "@verdaccio/logger": "8.0.0-next-8.36",
+    "@verdaccio/middleware": "8.0.0-next-8.36",
+    "@verdaccio/package-filter": "13.0.0-next-8.3",
+    "@verdaccio/search-indexer": "8.0.0-next-8.6",
+    "@verdaccio/signature": "8.0.0-next-8.28",
+    "@verdaccio/streams": "10.2.1",
+    "@verdaccio/tarball": "13.0.0-next-8.36",
+    "@verdaccio/ui-theme": "8.0.0-next-8.30",
+    "@verdaccio/url": "13.0.0-next-8.36",
+    "@verdaccio/utils": "8.1.0-next-8.36",
+    "JSONStream": "1.3.5",
+    "async": "3.2.6",
+    "clipanion": "4.0.0-rc.4",
+    "compression": "1.8.1",
+    "cors": "2.8.6",
+    "debug": "4.4.3",
+    "envinfo": "7.21.0",
+    "express": "4.22.1",
+    "lodash": "4.18.1",
+    "lru-cache": "7.18.3",
+    "mime": "3.0.0",
+    "semver": "7.7.4",
+    "verdaccio-audit": "13.0.0-next-8.36",
+    "verdaccio-htpasswd": "13.0.0-next-8.36"
+  },
+  "devDependencies": {
+    "@babel/cli": "7.28.6",
+    "@babel/core": "7.29.0",
+    "@babel/node": "7.29.0",
+    "@babel/preset-env": "7.29.0",
+    "@babel/preset-typescript": "7.28.5",
+    "@babel/register": "7.28.6",
+    "@babel/runtime": "7.28.6",
+    "@trivago/prettier-plugin-sort-imports": "5.2.2",
+    "@types/async": "3.2.25",
+    "@types/debug": "4.1.12",
+    "@types/express": "4.17.25",
+    "@types/express-serve-static-core": "4.19.8",
+    "@types/http-errors": "2.0.5",
+    "@types/lodash": "4.17.23",
+    "@types/mime": "3.0.4",
+    "@types/minimatch": "5.1.2",
+    "@types/node": "20.19.33",
+    "@types/pino": "7.0.5",
+    "@types/request": "2.48.13",
+    "@types/semver": "7.7.1",
+    "@types/supertest": "6.0.3",
+    "@verdaccio-scope/verdaccio-auth-foo": "0.0.2",
+    "@verdaccio/e2e-cli": "2.3.0",
+    "@verdaccio/eslint-config": "13.0.0",
+    "@verdaccio/test-helper": "4.0.0-next-8.13",
+    "@verdaccio/types": "13.0.0-next-8.11",
+    "@vitest/coverage-v8": "3.2.4",
+    "@vitest/eslint-plugin": "1.6.9",
+    "babel-plugin-transform-inline-environment-variables": "0.4.4",
+    "cross-env": "10.1.0",
+    "eslint": "10.0.3",
+    "eslint-plugin-cypress": "6.1.0",
+    "eslint-plugin-jest": "29.15.0",
+    "eslint-plugin-react": "7.37.5",
+    "eslint-plugin-react-hooks": "7.0.1",
+    "eslint-plugin-verdaccio": "10.1.0",
+    "fs-extra": "11.3.2",
+    "get-port": "7.1.0",
+    "kleur": "4.1.5",
+    "nock": "13.5.6",
+    "node-mocks-http": "^1.17.2",
+    "prettier": "3.6.2",
+    "selfsigned": "5.5.0",
+    "standard-version": "9.5.0",
+    "supertest": "7.2.2",
+    "ts-node": "10.9.2",
+    "typescript": "5.9.3",
+    "verdaccio-auth-memory": "10.3.1",
+    "verdaccio-memory": "10.4.1",
+    "vitest": "3.2.4"
+  },
+  "keywords": [
+    "private",
+    "package",
+    "repository",
+    "registry",
+    "enterprise",
+    "modules",
+    "proxy",
+    "server",
+    "verdaccio"
+  ],
+  "scripts": {
+    "release": "standard-version -a -s",
+    "type-check": "tsc --noEmit",
+    "cache:clean": "yarn cache clean --mirror && yarn cache clean --all",
+    "type-check:watch": "yarn run type-check -- --watch",
+    "format": "prettier --write \"**/*.{js,jsx,ts,tsx,json,yml,yaml,md}\"",
+    "format:check": "prettier --check \"**/*.{js,jsx,ts,tsx,json,yml,yaml,md}\"",
+    "test": "cross-env NODE_ENV=test TZ=UTC FORCE_COLOR=1 vitest run",
+    "pre:ci": "yarn run lint",
+    "lint:ts": "yarn run type-check",
+    "lint": "eslint \"**/*.{js,jsx,ts}\"",
+    "lint:lockfile": "echo 'No lockfile linting available'",
+    "start": "yarn babel-node --extensions \".ts,.tsx\" src/lib/cli --inspect",
+    "start:brk": "yarn babel-node --extensions \".ts,.tsx\" src/lib/cli --inspect-brk",
+    "start:debug": "yarn node debug/bootstrap.js",
+    "start:run-server": "yarn node debug/bootstrap-runserver.js",
+    "build": "rm -Rf build && PACKAGE_VERSION=$(node -p \"require('./package.json').version\")  yarn babel src/ --out-dir build/ --copy-files --extensions \".ts,.tsx\" --source-maps inline",
+    "code:types": "tsc --emitDeclarationOnly -p tsconfig.json",
+    "code:docker-build": "yarn babel src/ --out-dir build/ --copy-files --extensions \".ts,.tsx\"",
+    "docker": "docker build -t verdaccio/verdaccio:local . --no-cache",
+    "docker:run": "docker run -it --rm -p 4873:4873 -e \"DEBUG=verdaccio*\" verdaccio/verdaccio:local"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "preferGlobal": true,
+  "license": "MIT",
+  "resolutions": {
+    "@types/serve-static": "1.15.10",
+    "@types/express-serve-static-core": "4.19.8"
+  },
+  "collective": {
+    "type": "opencollective",
+    "url": "https://opencollective.com/verdaccio",
+    "logo": "https://opencollective.com/verdaccio/logo.txt"
+  },
+  "packageManager": "yarn@4.9.2"
+}

package/security.txt

@@ -0,0 +1,5 @@
+Contact: verdaccio@pm.me
+Encryption: https://verdaccio.nyc3.digitaloceanspaces.com/gpg/publickey.verdaccio@pm.me.asc
+Acknowledgments: https://verdaccio.org/thanks.html
+Preferred-Languages: en
+Policy: https://github.com/verdaccio/verdaccio/security/policy

package/systemd/verdaccio.service

@@ -0,0 +1,11 @@
+[Unit]
+Description=Verdaccio lightweight npm proxy registry
+
+[Service]
+Type=simple
+Restart=on-failure
+User=verdaccio
+ExecStart=/usr/bin/verdaccio --config /etc/verdaccio/config.yaml
+
+[Install]
+WantedBy=multi-user.target