@verdaccio/plugin-verifier 1.0.0-next-9.1

package/build/types.d.ts

@@ -0,0 +1,80 @@
+import { PLUGIN_CATEGORY } from '@verdaccio/core';
+export type PluginCategory = (typeof PLUGIN_CATEGORY)[keyof typeof PLUGIN_CATEGORY];
+export interface VerifyPluginOptions {
+    /**
+     * The plugin identifier as it would appear in config.yaml.
+     * For file-based plugins, this is the folder name inside `pluginsFolder`.
+     * For npm plugins, this is the package name (without the prefix for unscoped packages).
+     */
+    pluginPath: string;
+    /**
+     * The plugin category to verify against.
+     */
+    category: PluginCategory;
+    /**
+     * Optional plugin configuration passed as the first argument when instantiating the plugin.
+     */
+    pluginConfig?: Record<string, unknown>;
+    /**
+     * Optional custom sanity check function. If not provided, the default
+     * sanity check for the given category is used.
+     */
+    sanityCheck?: (plugin: any) => boolean;
+    /**
+     * Plugin name prefix. Defaults to 'verdaccio'.
+     */
+    prefix?: string;
+    /**
+     * Absolute path to a plugins folder for file-based plugin loading.
+     * Maps to `config.plugins` in Verdaccio configuration.
+     */
+    pluginsFolder?: string;
+    /**
+     * Absolute path to the Verdaccio configuration file.
+     * Maps to `config.configPath` — required by plugins that resolve
+     * relative paths (e.g. htpasswd resolves its `file` relative to this).
+     */
+    configPath?: string;
+}
+export interface DiagnosticStep {
+    /**
+     * The verification phase this diagnostic refers to.
+     */
+    phase: 'resolve' | 'export' | 'instantiate' | 'sanity-check';
+    /**
+     * Whether this phase passed.
+     */
+    pass: boolean;
+    /**
+     * Human-readable message describing the result.
+     */
+    message: string;
+}
+export interface VerifyResult {
+    /**
+     * Whether the plugin was successfully loaded and passed all checks.
+     */
+    success: boolean;
+    /**
+     * The plugin identifier used.
+     */
+    pluginName: string;
+    /**
+     * The plugin category verified against.
+     */
+    category: PluginCategory;
+    /**
+     * Number of plugins successfully loaded.
+     */
+    pluginsLoaded: number;
+    /**
+     * Error message if loading failed.
+     */
+    error?: string;
+    /**
+     * Step-by-step diagnostics showing which phase passed or failed.
+     * Only populated when the plugin fails to load.
+     */
+    diagnostics?: DiagnosticStep[];
+}
+//# sourceMappingURL=types.d.ts.map

package/build/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,iBAAiB,CAAC;AAEvD,MAAM,MAAM,cAAc,GAAG,CAAC,OAAO,eAAe,CAAC,CAAC,MAAM,OAAO,eAAe,CAAC,CAAC;AAEpF,MAAM,WAAW,mBAAmB;IAClC;;;;OAIG;IACH,UAAU,EAAE,MAAM,CAAC;IACnB;;OAEG;IACH,QAAQ,EAAE,cAAc,CAAC;IACzB;;OAEG;IACH,YAAY,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IACvC;;;OAGG;IACH,WAAW,CAAC,EAAE,CAAC,MAAM,EAAE,GAAG,KAAK,OAAO,CAAC;IACvC;;OAEG;IACH,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB;;;OAGG;IACH,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB;;;;OAIG;IACH,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AAED,MAAM,WAAW,cAAc;IAC7B;;OAEG;IACH,KAAK,EAAE,SAAS,GAAG,QAAQ,GAAG,aAAa,GAAG,cAAc,CAAC;IAC7D;;OAEG;IACH,IAAI,EAAE,OAAO,CAAC;IACd;;OAEG;IACH,OAAO,EAAE,MAAM,CAAC;CACjB;AAED,MAAM,WAAW,YAAY;IAC3B;;OAEG;IACH,OAAO,EAAE,OAAO,CAAC;IACjB;;OAEG;IACH,UAAU,EAAE,MAAM,CAAC;IACnB;;OAEG;IACH,QAAQ,EAAE,cAAc,CAAC;IACzB;;OAEG;IACH,aAAa,EAAE,MAAM,CAAC;IACtB;;OAEG;IACH,KAAK,CAAC,EAAE,MAAM,CAAC;IACf;;;OAGG;IACH,WAAW,CAAC,EAAE,cAAc,EAAE,CAAC;CAChC"}

package/build/verify-plugin.cjs

@@ -0,0 +1,87 @@
+const require_runtime = require("./_virtual/_rolldown/runtime.cjs");
+const require_sanity_checks = require("./sanity-checks.cjs");
+const require_diagnostics = require("./diagnostics.cjs");
+let debug = require("debug");
+debug = require_runtime.__toESM(debug);
+let node_path = require("node:path");
+let _verdaccio_core = require("@verdaccio/core");
+let _verdaccio_loaders = require("@verdaccio/loaders");
+let _verdaccio_logger = require("@verdaccio/logger");
+//#region src/verify-plugin.ts
+var debug$1 = (0, debug.default)("verdaccio:plugin:verifier");
+/**
+* Verifies that a plugin can be loaded by Verdaccio.
+*
+* Uses `asyncLoadPlugin` from `@verdaccio/loaders` — the same loader
+* Verdaccio uses at startup — so the verification is identical to what
+* happens in production.
+*
+* Steps verified:
+* 1. Module resolution — can the plugin be found/required?
+* 2. Export validation — does it export a function or a class (default export)?
+* 3. Instantiation — can the plugin be instantiated with a config and options?
+* 4. Sanity check — does the instance implement the required methods for its category?
+*
+* When loading fails, detailed diagnostics are included in the result
+* to pinpoint exactly which step failed and why.
+*/
+async function verifyPlugin(options) {
+	const { pluginPath, category, pluginConfig = {}, sanityCheck: customSanityCheck, prefix = _verdaccio_core.PLUGIN_PREFIX, pluginsFolder, configPath } = options;
+	debug$1("verifying plugin %o for category %o", pluginPath, category);
+	debug$1("prefix: %o, pluginsFolder: %o", prefix, pluginsFolder);
+	await (0, _verdaccio_logger.setup)({});
+	const sanityCheck = customSanityCheck ?? require_sanity_checks.getSanityCheck(category);
+	debug$1("using %s sanity check", customSanityCheck ? "custom" : "default");
+	const config = { ...pluginConfig };
+	if (pluginsFolder) {
+		config.plugins = (0, node_path.resolve)(pluginsFolder);
+		debug$1("resolved plugins folder: %o", config.plugins);
+	}
+	if (configPath) {
+		config.configPath = configPath;
+		debug$1("config path: %o", config.configPath);
+	}
+	const pluginConfigs = { [pluginPath]: pluginConfig };
+	debug$1("plugin config: %o", pluginConfigs);
+	try {
+		const plugins = await (0, _verdaccio_loaders.asyncLoadPlugin)(pluginConfigs, {
+			config,
+			logger: _verdaccio_logger.logger
+		}, sanityCheck, false, prefix, category);
+		debug$1("plugins loaded: %o", plugins.length);
+		if (plugins.length > 0) {
+			debug$1("verification succeeded for %o", pluginPath);
+			return {
+				success: true,
+				pluginName: pluginPath,
+				category,
+				pluginsLoaded: plugins.length
+			};
+		}
+		debug$1("verification failed, running diagnostics for %o", pluginPath);
+		const diagnostics = await require_diagnostics.runDiagnostics(options);
+		return {
+			success: false,
+			pluginName: pluginPath,
+			category,
+			pluginsLoaded: 0,
+			error: diagnostics.find((d) => !d.pass)?.message ?? `Plugin "${pluginPath}" could not be loaded for category "${category}"`,
+			diagnostics
+		};
+	} catch (err) {
+		debug$1("verification error for %o: %o", pluginPath, err.message);
+		const diagnostics = await require_diagnostics.runDiagnostics(options);
+		return {
+			success: false,
+			pluginName: pluginPath,
+			category,
+			pluginsLoaded: 0,
+			error: err.message,
+			diagnostics
+		};
+	}
+}
+//#endregion
+exports.verifyPlugin = verifyPlugin;
+
+//# sourceMappingURL=verify-plugin.cjs.map

package/build/verify-plugin.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"verify-plugin.cjs","names":[],"sources":["../src/verify-plugin.ts"],"sourcesContent":["import buildDebug from 'debug';\nimport { resolve } from 'node:path';\n\nimport { PLUGIN_PREFIX } from '@verdaccio/core';\nimport { asyncLoadPlugin } from '@verdaccio/loaders';\nimport { logger, setup } from '@verdaccio/logger';\n\nimport { runDiagnostics } from './diagnostics';\nimport { getSanityCheck } from './sanity-checks';\nimport type { VerifyPluginOptions, VerifyResult } from './types';\n\nconst debug = buildDebug('verdaccio:plugin:verifier');\n\n/**\n * Verifies that a plugin can be loaded by Verdaccio.\n *\n * Uses `asyncLoadPlugin` from `@verdaccio/loaders` — the same loader\n * Verdaccio uses at startup — so the verification is identical to what\n * happens in production.\n *\n * Steps verified:\n * 1. Module resolution — can the plugin be found/required?\n * 2. Export validation — does it export a function or a class (default export)?\n * 3. Instantiation — can the plugin be instantiated with a config and options?\n * 4. Sanity check — does the instance implement the required methods for its category?\n *\n * When loading fails, detailed diagnostics are included in the result\n * to pinpoint exactly which step failed and why.\n */\nexport async function verifyPlugin(options: VerifyPluginOptions): Promise<VerifyResult> {\n  const {\n    pluginPath,\n    category,\n    pluginConfig = {},\n    sanityCheck: customSanityCheck,\n    prefix = PLUGIN_PREFIX,\n    pluginsFolder,\n    configPath,\n  } = options;\n\n  debug('verifying plugin %o for category %o', pluginPath, category);\n  debug('prefix: %o, pluginsFolder: %o', prefix, pluginsFolder);\n\n  await setup({});\n\n  const sanityCheck = customSanityCheck ?? getSanityCheck(category);\n  debug('using %s sanity check', customSanityCheck ? 'custom' : 'default');\n\n  const config: any = {\n    ...pluginConfig,\n  };\n\n  if (pluginsFolder) {\n    config.plugins = resolve(pluginsFolder);\n    debug('resolved plugins folder: %o', config.plugins);\n  }\n\n  if (configPath) {\n    config.configPath = configPath;\n    debug('config path: %o', config.configPath);\n  }\n\n  const pluginConfigs = { [pluginPath]: pluginConfig };\n  debug('plugin config: %o', pluginConfigs);\n\n  try {\n    const plugins = await asyncLoadPlugin(\n      pluginConfigs,\n      { config, logger },\n      sanityCheck,\n      false,\n      prefix,\n      category\n    );\n\n    debug('plugins loaded: %o', plugins.length);\n\n    if (plugins.length > 0) {\n      debug('verification succeeded for %o', pluginPath);\n      return {\n        success: true,\n        pluginName: pluginPath,\n        category,\n        pluginsLoaded: plugins.length,\n      };\n    }\n\n    debug('verification failed, running diagnostics for %o', pluginPath);\n    const diagnostics = await runDiagnostics(options);\n    const failedStep = diagnostics.find((d) => !d.pass);\n\n    return {\n      success: false,\n      pluginName: pluginPath,\n      category,\n      pluginsLoaded: 0,\n      error:\n        failedStep?.message ??\n        `Plugin \"${pluginPath}\" could not be loaded for category \"${category}\"`,\n      diagnostics,\n    };\n  } catch (err: any) {\n    debug('verification error for %o: %o', pluginPath, err.message);\n    const diagnostics = await runDiagnostics(options);\n\n    return {\n      success: false,\n      pluginName: pluginPath,\n      category,\n      pluginsLoaded: 0,\n      error: err.message,\n      diagnostics,\n    };\n  }\n}\n"],"mappings":";;;;;;;;;;AAWA,IAAM,WAAA,GAAA,MAAA,SAAmB,4BAA4B;;;;;;;;;;;;;;;;;AAkBrD,eAAsB,aAAa,SAAqD;CACtF,MAAM,EACJ,YACA,UACA,eAAe,EAAE,EACjB,aAAa,mBACb,SAAS,gBAAA,eACT,eACA,eACE;AAEJ,SAAM,uCAAuC,YAAY,SAAS;AAClE,SAAM,iCAAiC,QAAQ,cAAc;AAE7D,QAAA,GAAA,kBAAA,OAAY,EAAE,CAAC;CAEf,MAAM,cAAc,qBAAqB,sBAAA,eAAe,SAAS;AACjE,SAAM,yBAAyB,oBAAoB,WAAW,UAAU;CAExE,MAAM,SAAc,EAClB,GAAG,cACJ;AAED,KAAI,eAAe;AACjB,SAAO,WAAA,GAAA,UAAA,SAAkB,cAAc;AACvC,UAAM,+BAA+B,OAAO,QAAQ;;AAGtD,KAAI,YAAY;AACd,SAAO,aAAa;AACpB,UAAM,mBAAmB,OAAO,WAAW;;CAG7C,MAAM,gBAAgB,GAAG,aAAa,cAAc;AACpD,SAAM,qBAAqB,cAAc;AAEzC,KAAI;EACF,MAAM,UAAU,OAAA,GAAA,mBAAA,iBACd,eACA;GAAE;GAAQ,QAAA,kBAAA;GAAQ,EAClB,aACA,OACA,QACA,SACD;AAED,UAAM,sBAAsB,QAAQ,OAAO;AAE3C,MAAI,QAAQ,SAAS,GAAG;AACtB,WAAM,iCAAiC,WAAW;AAClD,UAAO;IACL,SAAS;IACT,YAAY;IACZ;IACA,eAAe,QAAQ;IACxB;;AAGH,UAAM,mDAAmD,WAAW;EACpE,MAAM,cAAc,MAAM,oBAAA,eAAe,QAAQ;AAGjD,SAAO;GACL,SAAS;GACT,YAAY;GACZ;GACA,eAAe;GACf,OAPiB,YAAY,MAAM,MAAM,CAAC,EAAE,KAAK,EAQnC,WACZ,WAAW,WAAW,sCAAsC,SAAS;GACvE;GACD;UACM,KAAU;AACjB,UAAM,iCAAiC,YAAY,IAAI,QAAQ;EAC/D,MAAM,cAAc,MAAM,oBAAA,eAAe,QAAQ;AAEjD,SAAO;GACL,SAAS;GACT,YAAY;GACZ;GACA,eAAe;GACf,OAAO,IAAI;GACX;GACD"}

package/build/verify-plugin.d.ts

@@ -0,0 +1,19 @@
+import { VerifyPluginOptions, VerifyResult } from './types';
+/**
+ * Verifies that a plugin can be loaded by Verdaccio.
+ *
+ * Uses `asyncLoadPlugin` from `@verdaccio/loaders` — the same loader
+ * Verdaccio uses at startup — so the verification is identical to what
+ * happens in production.
+ *
+ * Steps verified:
+ * 1. Module resolution — can the plugin be found/required?
+ * 2. Export validation — does it export a function or a class (default export)?
+ * 3. Instantiation — can the plugin be instantiated with a config and options?
+ * 4. Sanity check — does the instance implement the required methods for its category?
+ *
+ * When loading fails, detailed diagnostics are included in the result
+ * to pinpoint exactly which step failed and why.
+ */
+export declare function verifyPlugin(options: VerifyPluginOptions): Promise<VerifyResult>;
+//# sourceMappingURL=verify-plugin.d.ts.map

package/build/verify-plugin.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"verify-plugin.d.ts","sourceRoot":"","sources":["../src/verify-plugin.ts"],"names":[],"mappings":"AASA,OAAO,KAAK,EAAE,mBAAmB,EAAE,YAAY,EAAE,MAAM,SAAS,CAAC;AAIjE;;;;;;;;;;;;;;;GAeG;AACH,wBAAsB,YAAY,CAAC,OAAO,EAAE,mBAAmB,GAAG,OAAO,CAAC,YAAY,CAAC,CAqFtF"}

package/build/verify-plugin.js

@@ -0,0 +1,85 @@
+import { getSanityCheck } from "./sanity-checks.js";
+import { runDiagnostics } from "./diagnostics.js";
+import buildDebug from "debug";
+import { resolve } from "node:path";
+import { PLUGIN_PREFIX } from "@verdaccio/core";
+import { asyncLoadPlugin } from "@verdaccio/loaders";
+import { logger, setup } from "@verdaccio/logger";
+//#region src/verify-plugin.ts
+var debug = buildDebug("verdaccio:plugin:verifier");
+/**
+* Verifies that a plugin can be loaded by Verdaccio.
+*
+* Uses `asyncLoadPlugin` from `@verdaccio/loaders` — the same loader
+* Verdaccio uses at startup — so the verification is identical to what
+* happens in production.
+*
+* Steps verified:
+* 1. Module resolution — can the plugin be found/required?
+* 2. Export validation — does it export a function or a class (default export)?
+* 3. Instantiation — can the plugin be instantiated with a config and options?
+* 4. Sanity check — does the instance implement the required methods for its category?
+*
+* When loading fails, detailed diagnostics are included in the result
+* to pinpoint exactly which step failed and why.
+*/
+async function verifyPlugin(options) {
+	const { pluginPath, category, pluginConfig = {}, sanityCheck: customSanityCheck, prefix = PLUGIN_PREFIX, pluginsFolder, configPath } = options;
+	debug("verifying plugin %o for category %o", pluginPath, category);
+	debug("prefix: %o, pluginsFolder: %o", prefix, pluginsFolder);
+	await setup({});
+	const sanityCheck = customSanityCheck ?? getSanityCheck(category);
+	debug("using %s sanity check", customSanityCheck ? "custom" : "default");
+	const config = { ...pluginConfig };
+	if (pluginsFolder) {
+		config.plugins = resolve(pluginsFolder);
+		debug("resolved plugins folder: %o", config.plugins);
+	}
+	if (configPath) {
+		config.configPath = configPath;
+		debug("config path: %o", config.configPath);
+	}
+	const pluginConfigs = { [pluginPath]: pluginConfig };
+	debug("plugin config: %o", pluginConfigs);
+	try {
+		const plugins = await asyncLoadPlugin(pluginConfigs, {
+			config,
+			logger
+		}, sanityCheck, false, prefix, category);
+		debug("plugins loaded: %o", plugins.length);
+		if (plugins.length > 0) {
+			debug("verification succeeded for %o", pluginPath);
+			return {
+				success: true,
+				pluginName: pluginPath,
+				category,
+				pluginsLoaded: plugins.length
+			};
+		}
+		debug("verification failed, running diagnostics for %o", pluginPath);
+		const diagnostics = await runDiagnostics(options);
+		return {
+			success: false,
+			pluginName: pluginPath,
+			category,
+			pluginsLoaded: 0,
+			error: diagnostics.find((d) => !d.pass)?.message ?? `Plugin "${pluginPath}" could not be loaded for category "${category}"`,
+			diagnostics
+		};
+	} catch (err) {
+		debug("verification error for %o: %o", pluginPath, err.message);
+		const diagnostics = await runDiagnostics(options);
+		return {
+			success: false,
+			pluginName: pluginPath,
+			category,
+			pluginsLoaded: 0,
+			error: err.message,
+			diagnostics
+		};
+	}
+}
+//#endregion
+export { verifyPlugin };
+
+//# sourceMappingURL=verify-plugin.js.map

package/build/verify-plugin.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"verify-plugin.js","names":[],"sources":["../src/verify-plugin.ts"],"sourcesContent":["import buildDebug from 'debug';\nimport { resolve } from 'node:path';\n\nimport { PLUGIN_PREFIX } from '@verdaccio/core';\nimport { asyncLoadPlugin } from '@verdaccio/loaders';\nimport { logger, setup } from '@verdaccio/logger';\n\nimport { runDiagnostics } from './diagnostics';\nimport { getSanityCheck } from './sanity-checks';\nimport type { VerifyPluginOptions, VerifyResult } from './types';\n\nconst debug = buildDebug('verdaccio:plugin:verifier');\n\n/**\n * Verifies that a plugin can be loaded by Verdaccio.\n *\n * Uses `asyncLoadPlugin` from `@verdaccio/loaders` — the same loader\n * Verdaccio uses at startup — so the verification is identical to what\n * happens in production.\n *\n * Steps verified:\n * 1. Module resolution — can the plugin be found/required?\n * 2. Export validation — does it export a function or a class (default export)?\n * 3. Instantiation — can the plugin be instantiated with a config and options?\n * 4. Sanity check — does the instance implement the required methods for its category?\n *\n * When loading fails, detailed diagnostics are included in the result\n * to pinpoint exactly which step failed and why.\n */\nexport async function verifyPlugin(options: VerifyPluginOptions): Promise<VerifyResult> {\n  const {\n    pluginPath,\n    category,\n    pluginConfig = {},\n    sanityCheck: customSanityCheck,\n    prefix = PLUGIN_PREFIX,\n    pluginsFolder,\n    configPath,\n  } = options;\n\n  debug('verifying plugin %o for category %o', pluginPath, category);\n  debug('prefix: %o, pluginsFolder: %o', prefix, pluginsFolder);\n\n  await setup({});\n\n  const sanityCheck = customSanityCheck ?? getSanityCheck(category);\n  debug('using %s sanity check', customSanityCheck ? 'custom' : 'default');\n\n  const config: any = {\n    ...pluginConfig,\n  };\n\n  if (pluginsFolder) {\n    config.plugins = resolve(pluginsFolder);\n    debug('resolved plugins folder: %o', config.plugins);\n  }\n\n  if (configPath) {\n    config.configPath = configPath;\n    debug('config path: %o', config.configPath);\n  }\n\n  const pluginConfigs = { [pluginPath]: pluginConfig };\n  debug('plugin config: %o', pluginConfigs);\n\n  try {\n    const plugins = await asyncLoadPlugin(\n      pluginConfigs,\n      { config, logger },\n      sanityCheck,\n      false,\n      prefix,\n      category\n    );\n\n    debug('plugins loaded: %o', plugins.length);\n\n    if (plugins.length > 0) {\n      debug('verification succeeded for %o', pluginPath);\n      return {\n        success: true,\n        pluginName: pluginPath,\n        category,\n        pluginsLoaded: plugins.length,\n      };\n    }\n\n    debug('verification failed, running diagnostics for %o', pluginPath);\n    const diagnostics = await runDiagnostics(options);\n    const failedStep = diagnostics.find((d) => !d.pass);\n\n    return {\n      success: false,\n      pluginName: pluginPath,\n      category,\n      pluginsLoaded: 0,\n      error:\n        failedStep?.message ??\n        `Plugin \"${pluginPath}\" could not be loaded for category \"${category}\"`,\n      diagnostics,\n    };\n  } catch (err: any) {\n    debug('verification error for %o: %o', pluginPath, err.message);\n    const diagnostics = await runDiagnostics(options);\n\n    return {\n      success: false,\n      pluginName: pluginPath,\n      category,\n      pluginsLoaded: 0,\n      error: err.message,\n      diagnostics,\n    };\n  }\n}\n"],"mappings":";;;;;;;;AAWA,IAAM,QAAQ,WAAW,4BAA4B;;;;;;;;;;;;;;;;;AAkBrD,eAAsB,aAAa,SAAqD;CACtF,MAAM,EACJ,YACA,UACA,eAAe,EAAE,EACjB,aAAa,mBACb,SAAS,eACT,eACA,eACE;AAEJ,OAAM,uCAAuC,YAAY,SAAS;AAClE,OAAM,iCAAiC,QAAQ,cAAc;AAE7D,OAAM,MAAM,EAAE,CAAC;CAEf,MAAM,cAAc,qBAAqB,eAAe,SAAS;AACjE,OAAM,yBAAyB,oBAAoB,WAAW,UAAU;CAExE,MAAM,SAAc,EAClB,GAAG,cACJ;AAED,KAAI,eAAe;AACjB,SAAO,UAAU,QAAQ,cAAc;AACvC,QAAM,+BAA+B,OAAO,QAAQ;;AAGtD,KAAI,YAAY;AACd,SAAO,aAAa;AACpB,QAAM,mBAAmB,OAAO,WAAW;;CAG7C,MAAM,gBAAgB,GAAG,aAAa,cAAc;AACpD,OAAM,qBAAqB,cAAc;AAEzC,KAAI;EACF,MAAM,UAAU,MAAM,gBACpB,eACA;GAAE;GAAQ;GAAQ,EAClB,aACA,OACA,QACA,SACD;AAED,QAAM,sBAAsB,QAAQ,OAAO;AAE3C,MAAI,QAAQ,SAAS,GAAG;AACtB,SAAM,iCAAiC,WAAW;AAClD,UAAO;IACL,SAAS;IACT,YAAY;IACZ;IACA,eAAe,QAAQ;IACxB;;AAGH,QAAM,mDAAmD,WAAW;EACpE,MAAM,cAAc,MAAM,eAAe,QAAQ;AAGjD,SAAO;GACL,SAAS;GACT,YAAY;GACZ;GACA,eAAe;GACf,OAPiB,YAAY,MAAM,MAAM,CAAC,EAAE,KAAK,EAQnC,WACZ,WAAW,WAAW,sCAAsC,SAAS;GACvE;GACD;UACM,KAAU;AACjB,QAAM,iCAAiC,YAAY,IAAI,QAAQ;EAC/D,MAAM,cAAc,MAAM,eAAe,QAAQ;AAEjD,SAAO;GACL,SAAS;GACT,YAAY;GACZ;GACA,eAAe;GACf,OAAO,IAAI;GACX;GACD"}

package/package.json

@@ -0,0 +1,63 @@
+{
+  "name": "@verdaccio/plugin-verifier",
+  "version": "1.0.0-next-9.1",
+  "description": "Tool to verify that a Verdaccio plugin can be loaded and passes sanity checks",
+  "type": "module",
+  "main": "./build/index.js",
+  "types": "build/index.d.ts",
+  "bin": {
+    "verdaccio-plugin-verifier": "./bin/verdaccio-plugin-verifier"
+  },
+  "author": {
+    "name": "Juan Picado",
+    "email": "juanpicado19@gmail.com"
+  },
+  "repository": {
+    "type": "https",
+    "url": "https://github.com/verdaccio/verdaccio",
+    "directory": "packages/tools/plugin-verifier"
+  },
+  "bugs": {
+    "url": "https://github.com/verdaccio/verdaccio/issues"
+  },
+  "license": "MIT",
+  "homepage": "https://verdaccio.org",
+  "keywords": [
+    "verdaccio",
+    "plugin",
+    "testing",
+    "verification",
+    "cli"
+  ],
+  "engines": {
+    "node": ">=24"
+  },
+  "dependencies": {
+    "@verdaccio/core": "9.0.0-next-9.5",
+    "@verdaccio/loaders": "9.0.0-next-9.5",
+    "@verdaccio/logger": "9.0.0-next-9.5",
+    "clipanion": "4.0.0-rc.4",
+    "debug": "4.4.3"
+  },
+  "devDependencies": {
+    "@verdaccio/config": "9.0.0-next-9.5",
+    "@verdaccio/types": "14.0.0-next-9.2",
+    "vitest": "4.1.0"
+  },
+  "funding": {
+    "type": "opencollective",
+    "url": "https://opencollective.com/verdaccio"
+  },
+  "exports": {
+    ".": {
+      "types": "./build/index.d.ts",
+      "import": "./build/index.js"
+    }
+  },
+  "scripts": {
+    "clean": "rimraf ./build",
+    "test": "vitest run",
+    "watch": "vite build --watch",
+    "build": "vite build"
+  }
+}

package/src/cli.ts

@@ -0,0 +1,14 @@
+import { Cli } from 'clipanion';
+
+import { VerifyCommand } from './commands/verify';
+
+const [node, app, ...args] = process.argv;
+
+const cli = new Cli({
+  binaryLabel: 'verdaccio-plugin-verifier',
+  binaryName: `${node} ${app}`,
+  binaryVersion: '1.0.0-next-9.0',
+});
+
+cli.register(VerifyCommand);
+cli.runExit(args, Cli.defaultContext);

package/src/commands/verify.ts

@@ -0,0 +1,100 @@
+import { Command, Option } from 'clipanion';
+import buildDebug from 'debug';
+
+import { PLUGIN_CATEGORY, PLUGIN_PREFIX } from '@verdaccio/core';
+
+import { verifyPlugin } from '../verify-plugin';
+
+const debug = buildDebug('verdaccio:plugin:verifier:cli');
+const VALID_CATEGORIES = Object.values(PLUGIN_CATEGORY);
+
+export class VerifyCommand extends Command {
+  public static paths = [Command.Default];
+
+  static usage = Command.Usage({
+    description: 'Verify that a Verdaccio plugin can be loaded and passes sanity checks',
+    details: `
+      This command uses the same plugin loader that Verdaccio runs at startup
+      (\`asyncLoadPlugin\` from \`@verdaccio/loaders\`) to verify that a plugin
+      can be resolved, instantiated, and passes the required sanity checks
+      for its category.
+
+      The plugin is identified by its short name (as it appears in \`config.yaml\`),
+      and the loader applies the prefix automatically. For example, \`my-auth\`
+      resolves to \`verdaccio-my-auth\` in the plugins folder or \`node_modules\`.
+
+      Scoped packages (e.g. \`@myorg/my-plugin\`) are used as-is without a prefix.
+
+      Enable debug output with the DEBUG environment variable:
+        DEBUG=verdaccio:plugin:verifier* verdaccio-plugin-verifier my-auth --category authentication
+    `,
+    examples: [
+      [
+        'Verify an auth plugin from a plugins folder',
+        'verdaccio-plugin-verifier my-auth --category authentication --plugins-folder ./plugins',
+      ],
+      [
+        'Verify a storage plugin installed via npm',
+        'verdaccio-plugin-verifier my-storage --category storage',
+      ],
+      [
+        'Verify a scoped plugin with a custom prefix',
+        'verdaccio-plugin-verifier @myorg/my-plugin --category middleware --prefix mycompany',
+      ],
+    ],
+  });
+
+  private pluginPath = Option.String({
+    required: true,
+    name: 'plugin',
+  });
+
+  private category = Option.String('--category,-c', {
+    required: true,
+    description: `Plugin category: ${VALID_CATEGORIES.join(', ')}`,
+  });
+
+  private pluginsFolder = Option.String('--plugins-folder,-d', {
+    description: 'Absolute path to the plugins directory (maps to config.plugins)',
+  });
+
+  private prefix = Option.String('--prefix,-p', {
+    description: `Plugin name prefix (default: "${PLUGIN_PREFIX}")`,
+  });
+
+  public async execute(): Promise<number> {
+    debug('command invoked with plugin=%o category=%o', this.pluginPath, this.category);
+    debug('pluginsFolder=%o prefix=%o', this.pluginsFolder, this.prefix);
+
+    if (!VALID_CATEGORIES.includes(this.category)) {
+      this.context.stderr.write(
+        `Error: Invalid category "${this.category}". Must be one of: ${VALID_CATEGORIES.join(', ')}\n`
+      );
+      return 1;
+    }
+
+    const result = await verifyPlugin({
+      pluginPath: this.pluginPath,
+      category: this.category,
+      pluginsFolder: this.pluginsFolder,
+      prefix: this.prefix,
+    });
+
+    if (result.success) {
+      this.context.stdout.write(
+        `Plugin "${result.pluginName}" verified successfully for category "${result.category}" (${result.pluginsLoaded} instance(s) loaded)\n`
+      );
+      return 0;
+    }
+
+    this.context.stderr.write(`Plugin verification failed: ${result.error}\n`);
+    if (result.diagnostics && result.diagnostics.length > 0) {
+      this.context.stderr.write('\nDiagnostics:\n');
+      for (const step of result.diagnostics) {
+        const icon = step.pass ? 'PASS' : 'FAIL';
+        this.context.stderr.write(`  [${icon}] ${step.phase}: ${step.message}\n`);
+      }
+    }
+    return 1;
+  }
+}