verdaccio 6.7.1 → 6.7.3

package/build/api/debug/index.d.ts

@@ -0,0 +1,3 @@
+import { Application } from 'express';
+declare const _default: (app: Application, selfPath: string) => void;
+export default _default;

package/build/api/endpoint/api/dist-tags.d.ts

@@ -0,0 +1,4 @@
+import type { Router } from 'express';
+import type { Auth } from '@verdaccio/auth';
+import type Storage from '../../../lib/storage';
+export default function (route: Router, auth: Auth, storage: Storage): void;

package/build/api/endpoint/api/package.d.ts

@@ -0,0 +1,5 @@
+import type { Router } from 'express';
+import type { Auth } from '@verdaccio/auth';
+import type { Config } from '@verdaccio/types';
+import type Storage from '../../../lib/storage';
+export default function (route: Router, auth: Auth, storage: Storage, config: Config): void;

package/build/api/endpoint/api/ping.d.ts

@@ -0,0 +1,2 @@
+import type { Router } from 'express';
+export default function (route: Router): void;

package/build/api/endpoint/api/publish.d.ts

@@ -0,0 +1,26 @@
+import type { Router } from 'express';
+import type { Auth } from '@verdaccio/auth';
+import type { Config } from '@verdaccio/types';
+import type Storage from '../../../lib/storage';
+import type { $NextFunctionVer, $RequestExtend, $ResponseExtend } from '../../../types';
+export default function publish(router: Router, auth: Auth, storage: Storage, config: Config): void;
+/**
+ * Publish a package
+ */
+export declare function publishPackage(storage: Storage, config: Config, auth: Auth): any;
+/**
+ * un-publish a package
+ */
+export declare function unPublishPackage(storage: Storage): (req: $RequestExtend, res: $ResponseExtend, next: $NextFunctionVer) => void;
+/**
+ * Delete tarball
+ */
+export declare function removeTarball(storage: Storage): (req: $RequestExtend, res: $ResponseExtend, next: $NextFunctionVer) => void;
+/**
+ * Adds a new version
+ */
+export declare function addVersion(storage: Storage): (req: $RequestExtend, res: $ResponseExtend, next: $NextFunctionVer) => void;
+/**
+ * uploadPackageTarball
+ */
+export declare function uploadPackageTarball(storage: Storage): (req: $RequestExtend, res: $ResponseExtend, next: $NextFunctionVer) => void;

package/build/api/endpoint/api/search.d.ts

@@ -0,0 +1 @@
+export default function (route: any, auth: any, storage: any): void;

package/build/api/endpoint/api/star.d.ts

@@ -0,0 +1,4 @@
+import type { Response } from 'express';
+import type Storage from '../../../lib/storage';
+import type { $NextFunctionVer, $RequestExtend } from '../../../types';
+export default function (storage: Storage): (req: $RequestExtend, res: Response, next: $NextFunctionVer) => void;

package/build/api/endpoint/api/stars.d.ts

@@ -0,0 +1,3 @@
+import type { Router } from 'express';
+import type Storage from '../../../lib/storage';
+export default function (route: Router, storage: Storage): void;

package/build/api/endpoint/api/user.d.ts

@@ -0,0 +1,4 @@
+import type { Router } from 'express';
+import type { Auth } from '@verdaccio/auth';
+import type { Config } from '@verdaccio/types';
+export default function (route: Router, auth: Auth, config: Config): void;

package/build/api/endpoint/api/v1/profile.d.ts

@@ -0,0 +1,14 @@
+import type { Router } from 'express';
+import type { Auth } from '@verdaccio/auth';
+import type { ConfigYaml } from '@verdaccio/types';
+export interface Profile {
+    tfa: boolean;
+    name: string;
+    email: string;
+    email_verified: boolean;
+    created: string;
+    updated: string;
+    cidr_whitelist: string[] | null;
+    fullname: string;
+}
+export default function (router: Router, auth: Auth, config: ConfigYaml): void;

package/build/api/endpoint/api/v1/search.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Endpoint for npm search v1
+ * req: 'GET /-/v1/search?text=react&size=20&from=0&quality=0.65&popularity=0.98&maintenance=0.5'
+ */
+export default function (route: any, auth: any, storage: any): void;

package/build/api/endpoint/api/v1/token.d.ts

@@ -0,0 +1,8 @@
+import type { Router } from 'express';
+import type { Auth } from '@verdaccio/auth';
+import type { Config, Token } from '@verdaccio/types';
+import type Storage from '../../../../lib/storage';
+export type NormalizeToken = Token & {
+    created: string;
+};
+export default function (router: Router, auth: Auth, storage: Storage, config: Config): void;

package/build/api/endpoint/api/v1/token.js

@@ -14,6 +14,11 @@ var _logger = require("../../../../lib/logger");
 var _utils = require("../../../../lib/utils");
 function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
 const debug = (0, _debug.default)('verdaccio:token');
+
+// Granular access token options (npm >= 11) that Verdaccio does not implement
+// yet. They are accepted so `npm token create` succeeds, but the restrictions
+// they express are NOT enforced — warn so the operator is not misled.
+const UNSUPPORTED_TOKEN_OPTIONS = ['packages_and_scopes_permission', 'packages', 'packages_all', 'scopes', 'orgs', 'orgs_permission', 'expires', 'description', 'bypass_2fa'];
 function normalizeToken(token) {
   return {
     ...token,
@@ -53,15 +58,27 @@ function _default(router, auth, storage, config) {
   router.post('/-/npm/v1/tokens', (0, _middleware.rateLimit)(config?.userRateLimit), function (req, res, next) {
     const {
       password,
-      readonly,
-      cidr_whitelist
+      readonly = false,
+      cidr_whitelist = []
     } = req.body;
     const {
       name
     } = req.remote_user;
+    // `readonly` and `cidr_whitelist` are optional: npm >= 11 rewrote
+    // `npm token create` to omit them (and only sends `cidr_whitelist` with
+    // `--cidr`), so default them rather than rejecting the request. A wrong
+    // type is still rejected.
+
     if (!_lodash.default.isBoolean(readonly) || !_lodash.default.isArray(cidr_whitelist)) {
       return next(_utils.ErrorCode.getCode(_constants.HTTP_STATUS.BAD_DATA, _constants.SUPPORT_ERRORS.PARAMETERS_NOT_VALID));
     }
+    const unsupportedOptions = UNSUPPORTED_TOKEN_OPTIONS.filter(option => _lodash.default.isNil(req.body[option]) === false);
+    if (unsupportedOptions.length > 0) {
+      _logger.logger.warn({
+        options: unsupportedOptions.join(', '),
+        userAgent: req.get('user-agent') ?? 'unknown'
+      }, 'granular access token options are not supported yet and will be ignored: @{options} (client: @{userAgent})');
+    }
     auth.authenticate(name, password, async (err, user) => {
       if (err) {
         const errorCode = err.message ? _constants.HTTP_STATUS.UNAUTHORIZED : _constants.HTTP_STATUS.INTERNAL_ERROR;
@@ -72,8 +89,10 @@ function _default(router, auth, storage, config) {
         return next(_utils.ErrorCode.getCode(_constants.HTTP_STATUS.NOT_IMPLEMENTED, _constants.SUPPORT_ERRORS.STORAGE_NOT_IMPLEMENT));
       }
       try {
-        const token = await (0, _auth.getApiToken)(auth, config, user, password);
-        const key = _core.cryptoUtils.stringToMD5(token);
+        const key = _core.cryptoUtils.generateRandomHexString(16);
+        const token = await (0, _auth.getApiToken)(auth, config, user, password, {
+          tokenKey: key
+        });
         // TODO: use a utility here
         const maskedToken = _core.cryptoUtils.mask(token, 5);
         const created = new Date().getTime();
@@ -137,4 +156,4 @@ function _default(router, auth, storage, config) {
     return next(_utils.ErrorCode.getUnauthorized());
   });
 }
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["_debug","_interopRequireDefault","require","_lodash","_auth","_core","_middleware","_constants","_logger","_utils","e","__esModule","default","debug","buildDebug","normalizeToken","token","created","Date","toISOString","_default","router","auth","storage","config","get","rateLimit","userRateLimit","req","res","next","name","remote_user","_","isNil","tokens","readTokens","user","totalTokens","length","status","HTTP_STATUS","OK","objects","map","urls","error","logger","msg","ErrorCode","getCode","INTERNAL_ERROR","message","getUnauthorized","post","password","readonly","cidr_whitelist","body","isBoolean","isArray","BAD_DATA","SUPPORT_ERRORS","PARAMETERS_NOT_VALID","authenticate","err","errorCode","UNAUTHORIZED","isFunction","saveToken","NOT_IMPLEMENTED","STORAGE_NOT_IMPLEMENT","getApiToken","key","cryptoUtils","stringToMD5","maskedToken","mask","getTime","cidr","set","HEADERS","CACHE_CONTROL","delete","params","tokenKey","deleteToken","info"],"sources":["../../../../../src/api/endpoint/api/v1/token.ts"],"sourcesContent":["import buildDebug from 'debug';\nimport type { Response, Router } from 'express';\nimport _ from 'lodash';\n\nimport { getApiToken } from '@verdaccio/auth';\nimport type { Auth } from '@verdaccio/auth';\nimport { cryptoUtils } from '@verdaccio/core';\nimport { rateLimit } from '@verdaccio/middleware';\nimport type { Config, RemoteUser, Token } from '@verdaccio/types';\n\nimport { HEADERS, HTTP_STATUS, SUPPORT_ERRORS } from '../../../../lib/constants';\nimport { logger } from '../../../../lib/logger';\nimport type Storage from '../../../../lib/storage';\nimport { ErrorCode } from '../../../../lib/utils';\nimport type { $NextFunctionVer, $RequestExtend } from '../../../../types';\n\nconst debug = buildDebug('verdaccio:token');\nexport type NormalizeToken = Token & {\n  created: string;\n};\n\nfunction normalizeToken(token: Token): NormalizeToken {\n  return {\n    ...token,\n    created: new Date(token.created).toISOString(),\n  };\n}\n\n// https://github.com/npm/npm-profile/blob/latest/lib/index.js\nexport default function (router: Router, auth: Auth, storage: Storage, config: Config) {\n  router.get(\n    '/-/npm/v1/tokens',\n    rateLimit(config?.userRateLimit),\n    async function (req: $RequestExtend, res: Response, next: $NextFunctionVer) {\n      const { name } = req.remote_user;\n\n      if (_.isNil(name) === false) {\n        try {\n          const tokens = await storage.readTokens({ user: name });\n          const totalTokens = tokens.length;\n          debug('token list retrieved: %o', totalTokens);\n          res.status(HTTP_STATUS.OK);\n          return next({\n            objects: tokens.map(normalizeToken),\n            urls: {\n              next: '', // TODO: pagination?\n            },\n          });\n        } catch (error: any) {\n          logger.error({ error: error.msg }, 'token list has failed: @{error}');\n          return next(ErrorCode.getCode(HTTP_STATUS.INTERNAL_ERROR, error.message));\n        }\n      }\n      return next(ErrorCode.getUnauthorized());\n    }\n  );\n\n  router.post(\n    '/-/npm/v1/tokens',\n    rateLimit(config?.userRateLimit),\n    function (req: $RequestExtend, res: Response, next: $NextFunctionVer) {\n      const { password, readonly, cidr_whitelist } = req.body;\n      const { name } = req.remote_user;\n\n      if (!_.isBoolean(readonly) || !_.isArray(cidr_whitelist)) {\n        return next(ErrorCode.getCode(HTTP_STATUS.BAD_DATA, SUPPORT_ERRORS.PARAMETERS_NOT_VALID));\n      }\n\n      auth.authenticate(name, password, async (err, user?: RemoteUser) => {\n        if (err) {\n          const errorCode = err.message ? HTTP_STATUS.UNAUTHORIZED : HTTP_STATUS.INTERNAL_ERROR;\n          return next(ErrorCode.getCode(errorCode, err.message));\n        }\n\n        req.remote_user = user;\n\n        if (!_.isFunction(storage.saveToken)) {\n          return next(\n            ErrorCode.getCode(HTTP_STATUS.NOT_IMPLEMENTED, SUPPORT_ERRORS.STORAGE_NOT_IMPLEMENT)\n          );\n        }\n\n        try {\n          const token = (await getApiToken(auth, config, user as RemoteUser, password)) as string;\n          const key = cryptoUtils.stringToMD5(token as string);\n          // TODO: use a utility here\n          const maskedToken = cryptoUtils.mask(token as string, 5);\n          const created = new Date().getTime();\n\n          /**\n           * cidr_whitelist: is not being used, we pass it through\n           * token: we do not store the real token (it is generated once and retrieved to the user), just a mask of it.\n           */\n          const saveToken: Token = {\n            user: name,\n            token: maskedToken,\n            key,\n            cidr: cidr_whitelist,\n            readonly,\n            created,\n          };\n\n          await storage.saveToken(saveToken);\n          debug('token %o was created for user %o', key, name);\n          res.set(HEADERS.CACHE_CONTROL, 'no-cache, no-store');\n          return next(\n            normalizeToken({\n              token,\n              user: name,\n              key: saveToken.key,\n              cidr: cidr_whitelist,\n              readonly,\n              created: saveToken.created,\n            })\n          );\n        } catch (error: any) {\n          logger.error({ error: error.msg }, 'token creation has failed: @{error}');\n          return next(ErrorCode.getCode(HTTP_STATUS.INTERNAL_ERROR, error.message));\n        }\n      });\n    }\n  );\n\n  router.delete(\n    '/-/npm/v1/tokens/token/:tokenKey',\n    rateLimit(config?.userRateLimit),\n    async (req: $RequestExtend, res: Response, next: $NextFunctionVer) => {\n      const {\n        params: { tokenKey },\n      } = req;\n      const { name } = req.remote_user;\n\n      if (_.isNil(name) === false) {\n        debug('%o has requested remove a token', name);\n        try {\n          await storage.deleteToken(name, tokenKey);\n          logger.info({ tokenKey, name }, 'token id @{tokenKey} was revoked for user @{name}');\n          return next({});\n        } catch (error: any) {\n          logger.error({ error: error.msg }, 'token creation has failed: @{error}');\n          return next(ErrorCode.getCode(HTTP_STATUS.INTERNAL_ERROR, error.message));\n        }\n      }\n      return next(ErrorCode.getUnauthorized());\n    }\n  );\n}\n"],"mappings":"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","ignoreList":[]}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["_debug","_interopRequireDefault","require","_lodash","_auth","_core","_middleware","_constants","_logger","_utils","e","__esModule","default","debug","buildDebug","UNSUPPORTED_TOKEN_OPTIONS","normalizeToken","token","created","Date","toISOString","_default","router","auth","storage","config","get","rateLimit","userRateLimit","req","res","next","name","remote_user","_","isNil","tokens","readTokens","user","totalTokens","length","status","HTTP_STATUS","OK","objects","map","urls","error","logger","msg","ErrorCode","getCode","INTERNAL_ERROR","message","getUnauthorized","post","password","readonly","cidr_whitelist","body","isBoolean","isArray","BAD_DATA","SUPPORT_ERRORS","PARAMETERS_NOT_VALID","unsupportedOptions","filter","option","warn","options","join","userAgent","authenticate","err","errorCode","UNAUTHORIZED","isFunction","saveToken","NOT_IMPLEMENTED","STORAGE_NOT_IMPLEMENT","key","cryptoUtils","generateRandomHexString","getApiToken","tokenKey","maskedToken","mask","getTime","cidr","set","HEADERS","CACHE_CONTROL","delete","params","deleteToken","info"],"sources":["../../../../../src/api/endpoint/api/v1/token.ts"],"sourcesContent":["import buildDebug from 'debug';\nimport type { Response, Router } from 'express';\nimport _ from 'lodash';\n\nimport { getApiToken } from '@verdaccio/auth';\nimport type { Auth } from '@verdaccio/auth';\nimport { cryptoUtils } from '@verdaccio/core';\nimport { rateLimit } from '@verdaccio/middleware';\nimport type { Config, RemoteUser, Token } from '@verdaccio/types';\n\nimport { HEADERS, HTTP_STATUS, SUPPORT_ERRORS } from '../../../../lib/constants';\nimport { logger } from '../../../../lib/logger';\nimport type Storage from '../../../../lib/storage';\nimport { ErrorCode } from '../../../../lib/utils';\nimport type { $NextFunctionVer, $RequestExtend } from '../../../../types';\n\nconst debug = buildDebug('verdaccio:token');\n\n// Granular access token options (npm >= 11) that Verdaccio does not implement\n// yet. They are accepted so `npm token create` succeeds, but the restrictions\n// they express are NOT enforced — warn so the operator is not misled.\nconst UNSUPPORTED_TOKEN_OPTIONS = [\n  'packages_and_scopes_permission',\n  'packages',\n  'packages_all',\n  'scopes',\n  'orgs',\n  'orgs_permission',\n  'expires',\n  'description',\n  'bypass_2fa',\n];\n\nexport type NormalizeToken = Token & {\n  created: string;\n};\n\nfunction normalizeToken(token: Token): NormalizeToken {\n  return {\n    ...token,\n    created: new Date(token.created).toISOString(),\n  };\n}\n\n// https://github.com/npm/npm-profile/blob/latest/lib/index.js\nexport default function (router: Router, auth: Auth, storage: Storage, config: Config) {\n  router.get(\n    '/-/npm/v1/tokens',\n    rateLimit(config?.userRateLimit),\n    async function (req: $RequestExtend, res: Response, next: $NextFunctionVer) {\n      const { name } = req.remote_user;\n\n      if (_.isNil(name) === false) {\n        try {\n          const tokens = await storage.readTokens({ user: name });\n          const totalTokens = tokens.length;\n          debug('token list retrieved: %o', totalTokens);\n          res.status(HTTP_STATUS.OK);\n          return next({\n            objects: tokens.map(normalizeToken),\n            urls: {\n              next: '', // TODO: pagination?\n            },\n          });\n        } catch (error: any) {\n          logger.error({ error: error.msg }, 'token list has failed: @{error}');\n          return next(ErrorCode.getCode(HTTP_STATUS.INTERNAL_ERROR, error.message));\n        }\n      }\n      return next(ErrorCode.getUnauthorized());\n    }\n  );\n\n  router.post(\n    '/-/npm/v1/tokens',\n    rateLimit(config?.userRateLimit),\n    function (req: $RequestExtend, res: Response, next: $NextFunctionVer) {\n      const { password, readonly = false, cidr_whitelist = [] } = req.body;\n      const { name } = req.remote_user;\n      // `readonly` and `cidr_whitelist` are optional: npm >= 11 rewrote\n      // `npm token create` to omit them (and only sends `cidr_whitelist` with\n      // `--cidr`), so default them rather than rejecting the request. A wrong\n      // type is still rejected.\n\n      if (!_.isBoolean(readonly) || !_.isArray(cidr_whitelist)) {\n        return next(ErrorCode.getCode(HTTP_STATUS.BAD_DATA, SUPPORT_ERRORS.PARAMETERS_NOT_VALID));\n      }\n\n      const unsupportedOptions = UNSUPPORTED_TOKEN_OPTIONS.filter(\n        (option) => _.isNil(req.body[option]) === false\n      );\n      if (unsupportedOptions.length > 0) {\n        logger.warn(\n          { options: unsupportedOptions.join(', '), userAgent: req.get('user-agent') ?? 'unknown' },\n          'granular access token options are not supported yet and will be ignored: @{options} (client: @{userAgent})'\n        );\n      }\n\n      auth.authenticate(name, password, async (err, user?: RemoteUser) => {\n        if (err) {\n          const errorCode = err.message ? HTTP_STATUS.UNAUTHORIZED : HTTP_STATUS.INTERNAL_ERROR;\n          return next(ErrorCode.getCode(errorCode, err.message));\n        }\n\n        req.remote_user = user;\n\n        if (!_.isFunction(storage.saveToken)) {\n          return next(\n            ErrorCode.getCode(HTTP_STATUS.NOT_IMPLEMENTED, SUPPORT_ERRORS.STORAGE_NOT_IMPLEMENT)\n          );\n        }\n\n        try {\n          const key = cryptoUtils.generateRandomHexString(16);\n          const token = (await getApiToken(auth, config, user as RemoteUser, password, {\n            tokenKey: key,\n          })) as string;\n          // TODO: use a utility here\n          const maskedToken = cryptoUtils.mask(token as string, 5);\n          const created = new Date().getTime();\n\n          /**\n           * cidr_whitelist: is not being used, we pass it through\n           * token: we do not store the real token (it is generated once and retrieved to the user), just a mask of it.\n           */\n          const saveToken: Token = {\n            user: name,\n            token: maskedToken,\n            key,\n            cidr: cidr_whitelist,\n            readonly,\n            created,\n          };\n\n          await storage.saveToken(saveToken);\n          debug('token %o was created for user %o', key, name);\n          res.set(HEADERS.CACHE_CONTROL, 'no-cache, no-store');\n          return next(\n            normalizeToken({\n              token,\n              user: name,\n              key: saveToken.key,\n              cidr: cidr_whitelist,\n              readonly,\n              created: saveToken.created,\n            })\n          );\n        } catch (error: any) {\n          logger.error({ error: error.msg }, 'token creation has failed: @{error}');\n          return next(ErrorCode.getCode(HTTP_STATUS.INTERNAL_ERROR, error.message));\n        }\n      });\n    }\n  );\n\n  router.delete(\n    '/-/npm/v1/tokens/token/:tokenKey',\n    rateLimit(config?.userRateLimit),\n    async (req: $RequestExtend, res: Response, next: $NextFunctionVer) => {\n      const {\n        params: { tokenKey },\n      } = req;\n      const { name } = req.remote_user;\n\n      if (_.isNil(name) === false) {\n        debug('%o has requested remove a token', name);\n        try {\n          await storage.deleteToken(name, tokenKey);\n          logger.info({ tokenKey, name }, 'token id @{tokenKey} was revoked for user @{name}');\n          return next({});\n        } catch (error: any) {\n          logger.error({ error: error.msg }, 'token creation has failed: @{error}');\n          return next(ErrorCode.getCode(HTTP_STATUS.INTERNAL_ERROR, error.message));\n        }\n      }\n      return next(ErrorCode.getUnauthorized());\n    }\n  );\n}\n"],"mappings":"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","ignoreList":[]}

package/build/api/endpoint/api/whoami.d.ts

@@ -0,0 +1,2 @@
+import type { Router } from 'express';
+export default function (route: Router): void;

package/build/api/endpoint/index.d.ts

@@ -0,0 +1,4 @@
+import type { Auth } from '@verdaccio/auth';
+import type { Config } from '@verdaccio/types';
+import type Storage from '../../lib/storage';
+export default function (config: Config, auth: Auth, storage: Storage): import("express-serve-static-core").Router;

package/build/api/endpoint/index.js

@@ -6,6 +6,7 @@ Object.defineProperty(exports, "__esModule", {
 exports.default = _default;
 var _express = _interopRequireDefault(require("express"));
 var _middleware = require("@verdaccio/middleware");
+var _logger = require("../../lib/logger");
 var _distTags = _interopRequireDefault(require("./api/dist-tags"));
 var _package = _interopRequireDefault(require("./api/package"));
 var _ping = _interopRequireDefault(require("./api/ping"));
@@ -35,6 +36,7 @@ function _default(config, auth, storage) {
   app.param('_rev', (0, _middleware.match)(/^-rev$/));
   app.param('org_couchdb_user', (0, _middleware.match)(/^org\.couchdb\.user:/));
   app.use(auth.apiJWTmiddleware());
+  app.use((0, _middleware.enforceGeneratedTokenMetadata)(storage, _logger.logger));
   app.use(_express.default.json({
     strict: false,
     limit: config.max_body_size || '10mb'
@@ -55,4 +57,4 @@ function _default(config, auth, storage) {
   (0, _package.default)(app, auth, storage, config);
   return app;
 }
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,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
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/build/api/index.d.ts

@@ -0,0 +1,4 @@
+import express from 'express';
+import type { ConfigYaml } from '@verdaccio/types';
+declare const _default: (configHash: ConfigYaml) => Promise<express.Application>;
+export default _default;

package/build/api/index.js

@@ -24,7 +24,7 @@ var _endpoint = _interopRequireDefault(require("./endpoint"));
 var _middleware2 = require("./middleware");
 var _web = _interopRequireDefault(require("./web"));
 function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
-const version = "6.7.1" || 'dev';
+const version = "6.7.3" || 'dev';
 const defineAPI = async function (config, storage) {
   const auth = new _auth.Auth(config, _logger.logger, {
     legacyMergeConfigs: true

package/build/api/middleware.d.ts

@@ -0,0 +1,3 @@
+import type { Config } from '@verdaccio/types';
+import type { $RequestExtend, $ResponseExtend } from '../types';
+export declare function serveFavicon(config: Config): (_req: $RequestExtend, res: $ResponseExtend) => void;

package/build/api/web/api/index.d.ts

@@ -0,0 +1,2 @@
+declare const _default: (auth: any, storage: any, config: any) => import("express-serve-static-core").Router;
+export default _default;

package/build/api/web/api/package.d.ts

@@ -0,0 +1,12 @@
+import { Router } from 'express';
+import type { Auth } from '@verdaccio/auth';
+import type { Config, Manifest } from '@verdaccio/types';
+import type Storage from '../../../lib/storage';
+export type PackcageExt = Manifest & {
+    author: any;
+    dist?: {
+        tarball: string;
+    };
+};
+declare function addPackageWebApi(storage: Storage, auth: Auth, config: Config): Router;
+export default addPackageWebApi;

package/build/api/web/api/search.d.ts

@@ -0,0 +1,5 @@
+import { Router } from 'express';
+import type { Auth } from '@verdaccio/auth';
+import type Storage from '../../../lib/storage';
+declare function addSearchWebApi(storage: Storage, auth: Auth): Router;
+export default addSearchWebApi;

package/build/api/web/api/user.d.ts

@@ -0,0 +1,5 @@
+import { Router } from 'express';
+import type { Auth } from '@verdaccio/auth';
+import type { Config } from '@verdaccio/types';
+declare function addUserAuthApi(auth: Auth, config: Config): Router;
+export default addUserAuthApi;

package/build/api/web/api/utils.d.ts

@@ -0,0 +1,2 @@
+export declare function wrapPath(urlPath: string): string;
+export declare function wrapSecPath(urlPath: string): string;

package/build/api/web/index.d.ts

@@ -0,0 +1,9 @@
+import type { RequestHandler } from 'express';
+import { Router } from 'express';
+export declare const PLUGIN_UI_PREFIX = "verdaccio-theme";
+export declare const DEFAULT_PLUGIN_UI_THEME = "@verdaccio/ui-theme";
+export declare function loadTheme(config: any): Promise<any>;
+export declare function webAPIMiddleware(tokenMiddleware: RequestHandler, webEndpointsApi: RequestHandler): Router;
+export declare function webMiddleware(config: any, middlewares: any, pluginOptions: any): any;
+declare const _default: (config: any, auth: any, storage: any, logger: any) => Promise<import("express-serve-static-core").Router>;
+export default _default;

package/build/index.d.ts

@@ -0,0 +1,4 @@
+export { startVerdaccio as default, startVerdaccio } from './lib/bootstrap';
+export { runServer } from './lib/run-server';
+export { ConfigBuilder, parseConfigFile, getDefaultConfig, Config } from '@verdaccio/config';
+export { fileUtils, errorUtils, cryptoUtils, pkgUtils } from '@verdaccio/core';

package/build/lib/auth-utils.d.ts

@@ -0,0 +1,2 @@
+import { Config, Security } from '@verdaccio/types';
+export declare function getSecurity(config: Config): Security;

package/build/lib/bootstrap.d.ts

@@ -0,0 +1,22 @@
+import { Application } from 'express';
+import { Callback, ConfigYaml } from '@verdaccio/types';
+/**
+ * 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
+ */
+declare function startVerdaccio(config: ConfigYaml, cliListen: string, configPath: string, pkgVersion: string, pkgName: string, callback: Callback): void;
+/**
+ *
+ * @param webServer
+ * @param addr
+ * @param pkgName
+ * @param pkgVersion
+ * @deprecated use initServer instead
+ */
+declare function listenDefaultCallback(webServer: Application, addr: any, pkgName: string, pkgVersion: string): void;
+export { startVerdaccio, listenDefaultCallback };

package/build/lib/cli/cli.d.ts

@@ -0,0 +1 @@
+export {};

package/build/lib/cli/cli.js

@@ -5,7 +5,7 @@ var _info = require("./commands/info");
 var _init = require("./commands/init");
 var _version = require("./commands/version");
 var _utils = require("./utils");
-const pkgVersion = "6.7.1" || 'dev';
+const pkgVersion = "6.7.3" || 'dev';
 if (process.getuid && process.getuid() === 0) {
   process.emitWarning(`Verdaccio doesn't need superuser privileges. don't run it under root`);
 }

package/build/lib/cli/commands/info.d.ts

@@ -0,0 +1,5 @@
+import { Command } from 'clipanion';
+export declare class InfoCommand extends Command {
+    static paths: string[][];
+    execute(): Promise<void>;
+}

package/build/lib/cli/commands/init.d.ts

@@ -0,0 +1,9 @@
+import { Command } from 'clipanion';
+export declare const DEFAULT_PROCESS_NAME: string;
+export declare class InitCommand extends Command {
+    static paths: never[][];
+    listen: string | undefined;
+    static usage: import("clipanion").Usage;
+    config: string | undefined;
+    execute(): Promise<void>;
+}

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

@@ -13,7 +13,7 @@ var _runServer = require("../../run-server");
 var _utils = require("../../utils");
 var _utils2 = require("../utils");
 function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
-const pkgVersion = "6.7.1" || 'dev';
+const pkgVersion = "6.7.3" || 'dev';
 const pkgName = 'verdaccio';
 const DEFAULT_PROCESS_NAME = exports.DEFAULT_PROCESS_NAME = 'verdaccio';
 class InitCommand extends _clipanion.Command {

package/build/lib/cli/commands/version.d.ts

@@ -0,0 +1,5 @@
+import { Command } from 'clipanion';
+export declare class VersionCommand extends Command {
+    static paths: string[][];
+    execute(): Promise<void>;
+}

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

@@ -5,7 +5,7 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.VersionCommand = void 0;
 var _clipanion = require("clipanion");
-const pkgVersion = "6.7.1" || 'dev';
+const pkgVersion = "6.7.3" || 'dev';
 class VersionCommand extends _clipanion.Command {
   static paths = [[`--version`], [`-v`]];
   async execute() {

package/build/lib/cli/utils.d.ts

@@ -0,0 +1,4 @@
+export declare const MIN_NODE_VERSION = "18";
+export declare const RECOMMENDED_NODE_VERSION = "22";
+export declare function isVersionValid(version: any): boolean;
+export declare function isVersionRecommended(version: any): boolean;

package/build/lib/cli.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+import './cli/cli';

package/build/lib/config.d.ts

@@ -0,0 +1,5 @@
+import { Config as ConfigCore } from '@verdaccio/config';
+declare class Config extends ConfigCore {
+    constructor(config: any);
+}
+export default Config;

package/build/lib/constants.d.ts

@@ -0,0 +1,25 @@
+export { API_ERROR, API_MESSAGE, HTTP_STATUS, HEADERS, HEADER_TYPE, CHARACTER_ENCODING, TOKEN_BASIC, TOKEN_BEARER, SUPPORT_ERRORS, APP_ERROR, DEFAULT_PROTOCOL, DEFAULT_DOMAIN, } from '@verdaccio/core';
+export { ROLES, PACKAGE_ACCESS } from '@verdaccio/utils';
+export declare const TIME_EXPIRATION_24H = "24h";
+export declare const TIME_EXPIRATION_1H = "1h";
+export declare const DIST_TAGS = "dist-tags";
+export declare const LATEST = "latest";
+export declare const USERS = "users";
+export declare const DEFAULT_MIN_LIMIT_PASSWORD = 3;
+export declare const keyPem = "verdaccio-key.pem";
+export declare const certPem = "verdaccio-cert.pem";
+export declare const csrPem = "verdaccio-csr.pem";
+export declare const ERROR_CODE: {
+    token_required: string;
+};
+export declare const DEFAULT_REGISTRY = "https://registry.npmjs.org";
+export declare const DEFAULT_UPLINK = "npmjs";
+export declare const DEFAULT_NO_README = "ERROR: No README data found!";
+export declare const MODULE_NOT_FOUND = "MODULE_NOT_FOUND";
+export declare const WEB_TITLE = "Verdaccio";
+export declare const STORAGE: {
+    PACKAGE_FILE_NAME: string;
+    FILE_EXIST_ERROR: string;
+    NO_SUCH_FILE_ERROR: string;
+    DEFAULT_REVISION: string;
+};

package/build/lib/experiments.d.ts

@@ -0,0 +1 @@
+export declare function displayExperimentsInfoBox(flags: any): any;