@grafana/create-plugin 7.16.0 → 7.17.0

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # Changelog
 
+## [7.17.0](https://github.com/grafana/plugin-tools/compare/@grafana/create-plugin@7.16.0...@grafana/create-plugin@7.17.0) (2026-10-28)
+
+
+### Features
+
+* remove dependency on glob ([#2655](https://github.com/grafana/plugin-tools/issues/2655)) ([9db0649](https://github.com/grafana/plugin-tools/commit/9db0649fd4dee9b5745a248ba421998cd9b86764))
+
+
+### Bug Fixes
+
+* **templates:** Update dependency @grafana/plugin-e2e to v3.15.2 ([#3022](https://github.com/grafana/plugin-tools/issues/3022)) ([2115b27](https://github.com/grafana/plugin-tools/commit/2115b27767554a555640300c7b4dc9c9e1842909))
+
 ## [7.16.0](https://github.com/grafana/plugin-tools/compare/@grafana/create-plugin@7.15.1...@grafana/create-plugin@7.16.0) (2026-10-22)
 
 

package/dist/codemods/migrations/migrations.js

@@ -108,11 +108,17 @@ var defaultMigrations = [
     version: "7.13.0",
     description: "Replace eslint-webpack-plugin with diagnostics-webpack-plugin in the webpack config. eslint-webpack-plugin depends on micromatch, which pulls in the braces dependency flagged by vulnerability scanners.",
     scriptPath: import.meta.resolve("./scripts/018-replace-eslint-webpack-plugin.js")
+  },
+  {
+    name: "019-remove-glob-dependency",
+    version: "7.17.0",
+    description: "Replace the glob package with the Node.js built-in fs.glob in bundler utils.",
+    scriptPath: import.meta.resolve("./scripts/019-remove-glob-dependency.js")
   }
   // Do not use LEGACY_UPDATE_CUTOFF_VERSION for new migrations. It is only used above to force migrations to run
   // for those written before the switch to updates as migrations.
   //
-  // New migrations never pick a version: copy the unreleased version line from ../AGENTS.md exactly.
+  // New migrations should never specify a version: copy the unreleased version line from ../AGENTS.md exactly.
   // Do not paste it into a comment in this file, as release-please rewrites every line that carries it.
 ];
 

package/dist/codemods/migrations/scripts/019-remove-glob-dependency.js

@@ -0,0 +1,93 @@
+import { parseAsTypescript, findImports, findNamedImport, findFunctionDeclaration, callsFunction, insertImports, createImport, printAST } from '../../utils.ast.js';
+import { removeDependenciesFromPackageJson, migrationsDebug } from '../../utils.js';
+
+const OLD_PACKAGE_NAME = "glob";
+const NEW_PACKAGE_NAME = "node:fs/promises";
+const UTILS_PATHS = [".config/webpack/utils.ts", ".config/bundler/utils.ts"];
+const GET_ENTRIES_SOURCE = `export async function getEntries() {
+  const plugins: string[][] = [];
+  for await (const pluginJson of glob('**/src/**/plugin.json')) {
+    const folder = path.dirname(pluginJson);
+    const modules: string[] = [];
+    for await (const module of glob(\`\${folder}/module.{ts,tsx,js,jsx}\`)) {
+      modules.push(path.resolve(module));
+    }
+    plugins.push(modules);
+  }
+
+  return plugins.reduce<Record<string, string>>((result, modules) => {
+    return modules.reduce((innerResult, module) => {
+      const pluginPath = path.dirname(module);
+      const pluginName = path.relative(process.cwd(), pluginPath).replace(/src\\/?/i, '');
+      const entryName = pluginName === '' ? 'module' : \`\${pluginName}/module\`;
+
+      innerResult[entryName] = module;
+      return innerResult;
+    }, result);
+  }, {});
+}`;
+function migrate(context) {
+  const updatedPaths = UTILS_PATHS.filter((filePath) => replaceGlobWithFsGlob(context, filePath));
+  if (updatedPaths.length === 0) {
+    return context;
+  }
+  const isStillUsed = UTILS_PATHS.some((filePath) => {
+    const source = context.getFile(filePath);
+    if (!source) {
+      return false;
+    }
+    const parsed = parseAsTypescript(source);
+    return !parsed.success || findImports(parsed.ast, OLD_PACKAGE_NAME).length > 0;
+  });
+  if (context.doesFileExist("package.json") && !isStillUsed) {
+    removeDependenciesFromPackageJson(context, [OLD_PACKAGE_NAME], [OLD_PACKAGE_NAME]);
+  }
+  return context;
+}
+function replaceGlobWithFsGlob(context, utilsPath) {
+  if (!context.doesFileExist(utilsPath)) {
+    return false;
+  }
+  const source = context.getFile(utilsPath);
+  if (!source || !source.includes(OLD_PACKAGE_NAME)) {
+    return false;
+  }
+  const parsed = parseAsTypescript(source);
+  if (!parsed.success) {
+    migrationsDebug(`Failed to parse ${utilsPath}. Error: ${parsed.error.message}`);
+    return false;
+  }
+  const globImport = findNamedImport(parsed.ast, OLD_PACKAGE_NAME, "glob");
+  if (!globImport) {
+    return false;
+  }
+  const getEntries = findFunctionDeclaration(parsed.ast, "getEntries");
+  if (!getEntries) {
+    return false;
+  }
+  if (!callsFunction(getEntries.body, "glob")) {
+    return false;
+  }
+  const { declaration, specifier } = globImport;
+  declaration.specifiers = (declaration.specifiers ?? []).filter((candidate) => candidate !== specifier);
+  if (declaration.specifiers.length === 0) {
+    parsed.ast.program.body.splice(parsed.ast.program.body.indexOf(declaration), 1);
+  }
+  insertImports(parsed.ast, [createImport({ named: [{ name: "glob" }] }, NEW_PACKAGE_NAME)]);
+  getEntries.body = getFunctionBody(GET_ENTRIES_SOURCE);
+  context.updateFile(utilsPath, printAST(parsed.ast));
+  return true;
+}
+function getFunctionBody(source) {
+  const parsed = parseAsTypescript(source);
+  if (!parsed.success) {
+    throw parsed.error;
+  }
+  const [statement] = parsed.ast.program.body;
+  if (statement?.type !== "ExportNamedDeclaration" || statement.declaration?.type !== "FunctionDeclaration") {
+    throw new Error("Failed to parse target function body");
+  }
+  return statement.declaration.body;
+}
+
+export { migrate as default };

package/dist/codemods/utils.ast.js

@@ -34,6 +34,33 @@ function findVariableDeclaration(ast, variableName) {
   });
   return found;
 }
+function findFunctionDeclaration(ast, functionName) {
+  let found = null;
+  recast.types.visit(ast, {
+    visitFunctionDeclaration(path) {
+      if (path.node.id?.name === functionName) {
+        found = path.node;
+        return false;
+      }
+      return this.traverse(path);
+    }
+  });
+  return found;
+}
+function callsFunction(ast, functionName) {
+  let isCalled = false;
+  recast.types.visit(ast, {
+    visitCallExpression(path) {
+      const { callee } = path.node;
+      if (callee.type === "Identifier" && callee.name === functionName) {
+        isCalled = true;
+        return false;
+      }
+      return this.traverse(path);
+    }
+  });
+  return isCalled;
+}
 function isProperty(node) {
   return node.type === "Property" || node.type === "ObjectProperty";
 }
@@ -71,5 +98,21 @@ function insertImports(ast, imports) {
     ast.program.body.unshift(...imports);
   }
 }
+function findImports(ast, packageName) {
+  return ast.program.body.filter(
+    (node) => node.type === "ImportDeclaration" && node.source.value === packageName
+  );
+}
+function findNamedImport(ast, packageName, importedName) {
+  for (const declaration of findImports(ast, packageName)) {
+    const specifier = declaration.specifiers?.find(
+      (candidate) => candidate.type === "ImportSpecifier" && candidate.imported.name === importedName
+    );
+    if (specifier) {
+      return { declaration, specifier };
+    }
+  }
+  return void 0;
+}
 
-export { createImport, findObjectProperty, findVariableDeclaration, insertImports, isProperty, parseAsTypescript, printAST };
+export { callsFunction, createImport, findFunctionDeclaration, findImports, findNamedImport, findObjectProperty, findVariableDeclaration, insertImports, isProperty, parseAsTypescript, printAST };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@grafana/create-plugin",
-  "version": "7.16.0",
+  "version": "7.17.0",
   "repository": {
     "type": "git",
     "directory": "packages/create-plugin",

package/src/codemods/migrations/migrations.ts

@@ -127,9 +127,15 @@ export default [
       'Replace eslint-webpack-plugin with diagnostics-webpack-plugin in the webpack config. eslint-webpack-plugin depends on micromatch, which pulls in the braces dependency flagged by vulnerability scanners.',
     scriptPath: import.meta.resolve('./scripts/018-replace-eslint-webpack-plugin.js'),
   },
+  {
+    name: '019-remove-glob-dependency',
+    version: '7.17.0',
+    description: 'Replace the glob package with the Node.js built-in fs.glob in bundler utils.',
+    scriptPath: import.meta.resolve('./scripts/019-remove-glob-dependency.js'),
+  },
   // Do not use LEGACY_UPDATE_CUTOFF_VERSION for new migrations. It is only used above to force migrations to run
   // for those written before the switch to updates as migrations.
   //
-  // New migrations never pick a version: copy the unreleased version line from ../AGENTS.md exactly.
+  // New migrations should never specify a version: copy the unreleased version line from ../AGENTS.md exactly.
   // Do not paste it into a comment in this file, as release-please rewrites every line that carries it.
 ] satisfies Migration[];

package/src/codemods/migrations/scripts/019-remove-glob-dependency.test.ts

@@ -0,0 +1,146 @@
+import { readFileSync } from 'node:fs';
+import { describe, expect, it } from 'vitest';
+import migrate from './019-remove-glob-dependency.js';
+import { createDefaultContext } from '../../test-utils.js';
+
+const BUNDLER_UTILS_PATH = '.config/bundler/utils.ts';
+const WEBPACK_UTILS_PATH = '.config/webpack/utils.ts';
+
+const CURRENT_UTILS = readFileSync(
+  new URL('../../../../templates/common/.config/bundler/utils.ts', import.meta.url),
+  'utf-8'
+);
+
+const NEW_GLOB_IMPORT = "import { glob } from 'node:fs/promises';";
+const CONSTANTS_IMPORT = "import { SOURCE_DIR } from './constants.ts';";
+
+// The migration appends the new import after the existing ones, so it lands below the constants import.
+const MIGRATED_UTILS = CURRENT_UTILS.replace(`${NEW_GLOB_IMPORT}\n`, '').replace(
+  CONSTANTS_IMPORT,
+  `${CONSTANTS_IMPORT}\n${NEW_GLOB_IMPORT}`
+);
+
+// The template's utils.ts as scaffolded before the glob package was removed.
+const SCAFFOLDED_UTILS = CURRENT_UTILS.replace(
+  "import { glob } from 'node:fs/promises';",
+  "import { glob } from 'glob';"
+).replace(
+  /export async function getEntries\(\) \{[\s\S]*?\n {2}return plugins\.reduce/,
+  `export async function getEntries() {
+  const pluginsJson = await glob('**/src/**/plugin.json', { absolute: true });
+
+  const plugins = await Promise.all(
+    pluginsJson.map((pluginJson) => {
+      const folder = path.dirname(pluginJson);
+      return glob(\`\${folder}/module.{ts,tsx,js,jsx}\`, { absolute: true });
+    })
+  );
+
+  return plugins.reduce`
+);
+
+function createContextWithGlob(utilsPath = BUNDLER_UTILS_PATH, utilsContent = SCAFFOLDED_UTILS) {
+  const context = createDefaultContext();
+  context.addFile(utilsPath, utilsContent);
+  context.updateFile(
+    'package.json',
+    JSON.stringify({ devDependencies: { '@grafana/tsconfig': '^2.0.1', glob: '^11.1.0' } }, null, 2)
+  );
+
+  return context;
+}
+
+function getDevDependencies(context: ReturnType<typeof createDefaultContext>) {
+  return JSON.parse(context.getFile('package.json') ?? '{}').devDependencies;
+}
+
+describe('Migration - remove glob dependency', () => {
+  it('should be idempotent', async () => {
+    const context = createContextWithGlob();
+
+    await expect(migrate).toBeIdempotent(context);
+  });
+
+  it('should migrate the scaffolded utils to the current template', () => {
+    const context = migrate(createContextWithGlob());
+
+    expect(context.getFile(BUNDLER_UTILS_PATH)).toBe(MIGRATED_UTILS);
+  });
+
+  it('should migrate the legacy webpack utils location', () => {
+    const context = migrate(createContextWithGlob(WEBPACK_UTILS_PATH));
+
+    expect(context.getFile(WEBPACK_UTILS_PATH)).toBe(MIGRATED_UTILS);
+  });
+
+  it('should remove glob from package.json', () => {
+    const context = migrate(createContextWithGlob());
+
+    expect(getDevDependencies(context)).toEqual({ '@grafana/tsconfig': '^2.0.1' });
+  });
+
+  it('should migrate a customised getEntries that calls glob', () => {
+    const customisedUtils = SCAFFOLDED_UTILS.replace(
+      '{ absolute: true });\n\n  const plugins',
+      "{ absolute: true, ignore: ['node_modules/**'] });\n\n  const plugins"
+    );
+    const context = migrate(createContextWithGlob(BUNDLER_UTILS_PATH, customisedUtils));
+
+    expect(context.getFile(BUNDLER_UTILS_PATH)).toBe(MIGRATED_UTILS);
+  });
+
+  it('should skip a getEntries that does not call glob', () => {
+    const noGlobCallUtils = SCAFFOLDED_UTILS.replace(
+      "const pluginsJson = await glob('**/src/**/plugin.json', { absolute: true });",
+      "const pluginsJson = ['src/plugin.json'];"
+    ).replace('return glob(', 'return Promise.resolve(');
+    const context = createContextWithGlob(BUNDLER_UTILS_PATH, noGlobCallUtils);
+
+    migrate(context);
+
+    expect(context.getFile(BUNDLER_UTILS_PATH)).toBe(noGlobCallUtils);
+    expect(getDevDependencies(context).glob).toBe('^11.1.0');
+  });
+
+  it('should skip an aliased glob import', () => {
+    const aliasedUtils = SCAFFOLDED_UTILS.replace("import { glob } from 'glob';", "import { glob as g } from 'glob';")
+      .replaceAll('await glob(', 'await g(')
+      .replace('return glob(', 'return g(');
+    const context = createContextWithGlob(BUNDLER_UTILS_PATH, aliasedUtils);
+
+    migrate(context);
+
+    expect(context.getFile(BUNDLER_UTILS_PATH)).toBe(aliasedUtils);
+    expect(getDevDependencies(context).glob).toBe('^11.1.0');
+  });
+
+  it('should keep other glob specifiers and the dependency', () => {
+    const mixedUtils = SCAFFOLDED_UTILS.replace(
+      "import { glob } from 'glob';",
+      "import { glob, globSync } from 'glob';"
+    );
+    const context = migrate(createContextWithGlob(BUNDLER_UTILS_PATH, mixedUtils));
+    const migrated = context.getFile(BUNDLER_UTILS_PATH);
+
+    expect(migrated).toContain("import { globSync } from 'glob';");
+    expect(migrated).toContain("import { glob } from 'node:fs/promises';");
+    expect(migrated).toContain("for await (const pluginJson of glob('**/src/**/plugin.json'))");
+    expect(getDevDependencies(context).glob).toBe('^11.1.0');
+  });
+
+  it('should leave files without a glob import unchanged', () => {
+    const context = createContextWithGlob(BUNDLER_UTILS_PATH, CURRENT_UTILS);
+
+    migrate(context);
+
+    expect(context.getFile(BUNDLER_UTILS_PATH)).toBe(CURRENT_UTILS);
+    expect(getDevDependencies(context).glob).toBe('^11.1.0');
+  });
+
+  it('should not fail when the utils file cannot be parsed', () => {
+    const context = createContextWithGlob(BUNDLER_UTILS_PATH, "import { glob } from 'glob';\nexport function {");
+
+    expect(() => migrate(context)).not.toThrow();
+    expect(getDevDependencies(context).glob).toBe('^11.1.0');
+  });
+});

package/src/codemods/migrations/scripts/019-remove-glob-dependency.ts

@@ -0,0 +1,121 @@
+import type { Context } from '../../context.js';
+import * as recast from 'recast';
+import {
+  callsFunction,
+  createImport,
+  findImports,
+  findFunctionDeclaration,
+  findNamedImport,
+  insertImports,
+  parseAsTypescript,
+  printAST,
+} from '../../utils.ast.js';
+import { migrationsDebug, removeDependenciesFromPackageJson } from '../../utils.js';
+
+const OLD_PACKAGE_NAME = 'glob';
+const NEW_PACKAGE_NAME = 'node:fs/promises';
+
+const UTILS_PATHS = ['.config/webpack/utils.ts', '.config/bundler/utils.ts'];
+
+const GET_ENTRIES_SOURCE = `export async function getEntries() {
+  const plugins: string[][] = [];
+  for await (const pluginJson of glob('**/src/**/plugin.json')) {
+    const folder = path.dirname(pluginJson);
+    const modules: string[] = [];
+    for await (const module of glob(\`\${folder}/module.{ts,tsx,js,jsx}\`)) {
+      modules.push(path.resolve(module));
+    }
+    plugins.push(modules);
+  }
+
+  return plugins.reduce<Record<string, string>>((result, modules) => {
+    return modules.reduce((innerResult, module) => {
+      const pluginPath = path.dirname(module);
+      const pluginName = path.relative(process.cwd(), pluginPath).replace(/src\\/?/i, '');
+      const entryName = pluginName === '' ? 'module' : \`\${pluginName}/module\`;
+
+      innerResult[entryName] = module;
+      return innerResult;
+    }, result);
+  }, {});
+}`;
+
+export default function migrate(context: Context) {
+  const updatedPaths = UTILS_PATHS.filter((filePath) => replaceGlobWithFsGlob(context, filePath));
+  if (updatedPaths.length === 0) {
+    return context;
+  }
+
+  const isStillUsed = UTILS_PATHS.some((filePath) => {
+    const source = context.getFile(filePath);
+    if (!source) {
+      return false;
+    }
+    const parsed = parseAsTypescript(source);
+    return !parsed.success || findImports(parsed.ast, OLD_PACKAGE_NAME).length > 0;
+  });
+
+  if (context.doesFileExist('package.json') && !isStillUsed) {
+    removeDependenciesFromPackageJson(context, [OLD_PACKAGE_NAME], [OLD_PACKAGE_NAME]);
+  }
+
+  return context;
+}
+
+function replaceGlobWithFsGlob(context: Context, utilsPath: string): boolean {
+  if (!context.doesFileExist(utilsPath)) {
+    return false;
+  }
+
+  const source = context.getFile(utilsPath);
+  if (!source || !source.includes(OLD_PACKAGE_NAME)) {
+    return false;
+  }
+
+  const parsed = parseAsTypescript(source);
+  if (!parsed.success) {
+    migrationsDebug(`Failed to parse ${utilsPath}. Error: ${parsed.error.message}`);
+    return false;
+  }
+
+  const globImport = findNamedImport(parsed.ast, OLD_PACKAGE_NAME, 'glob');
+  if (!globImport) {
+    return false;
+  }
+
+  const getEntries = findFunctionDeclaration(parsed.ast, 'getEntries');
+  if (!getEntries) {
+    return false;
+  }
+
+  // The new body calls glob directly, so an aliased import (and its calls) is left alone.
+  if (!callsFunction(getEntries.body, 'glob')) {
+    return false;
+  }
+
+  const { declaration, specifier } = globImport;
+  declaration.specifiers = (declaration.specifiers ?? []).filter((candidate) => candidate !== specifier);
+  if (declaration.specifiers.length === 0) {
+    parsed.ast.program.body.splice(parsed.ast.program.body.indexOf(declaration), 1);
+  }
+  insertImports(parsed.ast, [createImport({ named: [{ name: 'glob' }] }, NEW_PACKAGE_NAME)]);
+
+  getEntries.body = getFunctionBody(GET_ENTRIES_SOURCE);
+
+  context.updateFile(utilsPath, printAST(parsed.ast));
+  return true;
+}
+
+function getFunctionBody(source: string): recast.types.namedTypes.BlockStatement {
+  const parsed = parseAsTypescript(source);
+  if (!parsed.success) {
+    throw parsed.error;
+  }
+
+  const [statement] = parsed.ast.program.body;
+  if (statement?.type !== 'ExportNamedDeclaration' || statement.declaration?.type !== 'FunctionDeclaration') {
+    throw new Error('Failed to parse target function body');
+  }
+
+  return statement.declaration.body;
+}

package/src/codemods/utils.ast.test.ts

@@ -7,6 +7,10 @@ import {
   findObjectProperty,
   createImport,
   insertImports,
+  findImports,
+  findNamedImport,
+  findFunctionDeclaration,
+  callsFunction,
 } from './utils.ast.js';
 
 // Helper to create a simple test AST from source code
@@ -31,6 +35,58 @@ function findFirstNode<T extends recast.types.namedTypes.Node>(ast: recast.types
 }
 
 describe('utils.ast', () => {
+  describe('Declaration Utilities', () => {
+    describe('findFunctionDeclaration', () => {
+      it('should find a function declaration by name', () => {
+        const ast = createTestAST(`function foo() {}\nfunction bar() {}`);
+
+        const declaration = findFunctionDeclaration(ast, 'bar');
+
+        expect(declaration?.id?.name).toBe('bar');
+      });
+
+      it('should find an exported function declaration', () => {
+        const ast = createTestAST(`export async function getEntries() {}`);
+
+        const declaration = findFunctionDeclaration(ast, 'getEntries');
+
+        expect(declaration?.async).toBe(true);
+      });
+
+      it('should return null when the function is not declared', () => {
+        const ast = createTestAST(`const getEntries = () => {};`);
+
+        expect(findFunctionDeclaration(ast, 'getEntries')).toBeNull();
+      });
+    });
+
+    describe('callsFunction', () => {
+      it('should return true when the function is called', () => {
+        const ast = createTestAST(`async function run() { const files = await glob('**/*.ts'); }`);
+
+        expect(callsFunction(ast, 'glob')).toBe(true);
+      });
+
+      it('should return true for nested calls', () => {
+        const ast = createTestAST(`items.map((item) => wrap(glob(item)));`);
+
+        expect(callsFunction(ast, 'glob')).toBe(true);
+      });
+
+      it('should return false when the function is only referenced', () => {
+        const ast = createTestAST(`const fn = glob;`);
+
+        expect(callsFunction(ast, 'glob')).toBe(false);
+      });
+
+      it('should return false for a method with the same name', () => {
+        const ast = createTestAST(`fs.glob('**/*.ts');`);
+
+        expect(callsFunction(ast, 'glob')).toBe(false);
+      });
+    });
+  });
+
   describe('Property Utilities', () => {
     describe('isProperty', () => {
       it('should return true for Property nodes', () => {
@@ -191,5 +247,100 @@ describe('utils.ast', () => {
         expect(output).toBe(`import React from 'react';\nimport { map } from 'lodash';\nconst x = 1;`);
       });
     });
+
+    describe('findImports', () => {
+      it('should return an empty array when the package is not imported', () => {
+        const ast = createTestAST(`import React from 'react';\nconst x = 1;`);
+
+        expect(findImports(ast, 'glob')).toEqual([]);
+      });
+
+      it('should return the matching import declaration', () => {
+        const ast = createTestAST(`import React from 'react';\nimport { glob } from 'glob';`);
+
+        const imports = findImports(ast, 'glob');
+
+        expect(imports).toHaveLength(1);
+        expect(imports[0].source.value).toBe('glob');
+      });
+
+      it('should return every declaration importing the package', () => {
+        const ast = createTestAST(`import { glob } from 'glob';\nimport type { GlobOptions } from 'glob';`);
+
+        expect(findImports(ast, 'glob')).toHaveLength(2);
+      });
+
+      it('should not match packages with a similar name', () => {
+        const ast = createTestAST(`import globParent from 'glob-parent';\nimport { glob } from 'node:fs/promises';`);
+
+        expect(findImports(ast, 'glob')).toEqual([]);
+      });
+    });
+
+    describe('findNamedImport', () => {
+      it('should find a named import', () => {
+        const ast = createTestAST(`import { glob } from 'glob';`);
+
+        const match = findNamedImport(ast, 'glob', 'glob');
+
+        expect(match).toBeDefined();
+        expect(match?.declaration.source.value).toBe('glob');
+        expect(match?.specifier.imported.name).toBe('glob');
+        expect(match?.specifier.local?.name).toBe('glob');
+      });
+
+      it('should find an aliased named import by its imported name', () => {
+        const ast = createTestAST(`import { glob as g } from 'glob';`);
+
+        const match = findNamedImport(ast, 'glob', 'glob');
+
+        expect(match).toBeDefined();
+        expect(match?.specifier.local?.name).toBe('g');
+      });
+
+      it('should find the specifier among other specifiers', () => {
+        const ast = createTestAST(`import { globSync, glob } from 'glob';`);
+
+        const match = findNamedImport(ast, 'glob', 'glob');
+
+        expect(match).toBeDefined();
+        expect(match?.declaration.specifiers).toHaveLength(2);
+        expect(match?.specifier.imported.name).toBe('glob');
+      });
+
+      it('should find the specifier in a later declaration of the same package', () => {
+        const ast = createTestAST(`import type { GlobOptions } from 'glob';\nimport { glob } from 'glob';`);
+        const [, secondDeclaration] = findImports(ast, 'glob');
+
+        const match = findNamedImport(ast, 'glob', 'glob');
+
+        expect(match).toBeDefined();
+        expect(match?.declaration).toBe(secondDeclaration);
+      });
+
+      it('should return undefined when only other named imports exist', () => {
+        const ast = createTestAST(`import { globSync } from 'glob';`);
+
+        expect(findNamedImport(ast, 'glob', 'glob')).toBeUndefined();
+      });
+
+      it('should return undefined for a default import', () => {
+        const ast = createTestAST(`import glob from 'glob';`);
+
+        expect(findNamedImport(ast, 'glob', 'glob')).toBeUndefined();
+      });
+
+      it('should return undefined for a namespace import', () => {
+        const ast = createTestAST(`import * as glob from 'glob';`);
+
+        expect(findNamedImport(ast, 'glob', 'glob')).toBeUndefined();
+      });
+
+      it('should return undefined when the package is not imported', () => {
+        const ast = createTestAST(`import { glob } from 'node:fs/promises';`);
+
+        expect(findNamedImport(ast, 'glob', 'glob')).toBeUndefined();
+      });
+    });
   });
 });

package/src/codemods/utils.ast.ts

@@ -45,6 +45,42 @@ export function findVariableDeclaration(
   return found;
 }
 
+export function findFunctionDeclaration(
+  ast: recast.types.ASTNode,
+  functionName: string
+): recast.types.namedTypes.FunctionDeclaration | null {
+  let found = null;
+
+  recast.types.visit(ast, {
+    visitFunctionDeclaration(path) {
+      if (path.node.id?.name === functionName) {
+        found = path.node;
+        return false; // Stop traversal
+      }
+      return this.traverse(path);
+    },
+  });
+
+  return found;
+}
+
+export function callsFunction(ast: recast.types.ASTNode, functionName: string): boolean {
+  let isCalled = false;
+
+  recast.types.visit(ast, {
+    visitCallExpression(path) {
+      const { callee } = path.node;
+      if (callee.type === 'Identifier' && callee.name === functionName) {
+        isCalled = true;
+        return false; // Stop traversal
+      }
+      return this.traverse(path);
+    },
+  });
+
+  return isCalled;
+}
+
 export function isProperty(
   node: recast.types.ASTNode
 ): node is recast.types.namedTypes.Property | recast.types.namedTypes.ObjectProperty {
@@ -108,3 +144,27 @@ export function insertImports(
     ast.program.body.unshift(...imports);
   }
 }
+
+export function findImports(
+  ast: recast.types.namedTypes.File,
+  packageName: string
+): recast.types.namedTypes.ImportDeclaration[] {
+  return ast.program.body.filter(
+    (node): node is recast.types.namedTypes.ImportDeclaration =>
+      node.type === 'ImportDeclaration' && node.source.value === packageName
+  );
+}
+
+export function findNamedImport(ast: recast.types.namedTypes.File, packageName: string, importedName: string) {
+  for (const declaration of findImports(ast, packageName)) {
+    const specifier = declaration.specifiers?.find(
+      (candidate): candidate is recast.types.namedTypes.ImportSpecifier =>
+        candidate.type === 'ImportSpecifier' && candidate.imported.name === importedName
+    );
+    if (specifier) {
+      return { declaration, specifier };
+    }
+  }
+
+  return undefined;
+}

package/templates/common/.config/bundler/utils.ts

@@ -2,7 +2,7 @@ import fs from 'fs';
 import process from 'process';
 import os from 'os';
 import path from 'path';
-import { glob } from 'glob';
+import { glob } from 'node:fs/promises';
 import { SOURCE_DIR } from './constants.ts';
 
 export function isWSL() {
@@ -46,14 +46,15 @@ export function hasReadme() {
 // Support bundling nested plugins by finding all plugin.json files in src directory
 // then checking for a sibling module.[jt]sx? file.
 export async function getEntries() {
-  const pluginsJson = await glob('**/src/**/plugin.json', { absolute: true });
-
-  const plugins = await Promise.all(
-    pluginsJson.map((pluginJson) => {
-      const folder = path.dirname(pluginJson);
-      return glob(`${folder}/module.{ts,tsx,js,jsx}`, { absolute: true });
-    })
-  );
+  const plugins: string[][] = [];
+  for await (const pluginJson of glob('**/src/**/plugin.json')) {
+    const folder = path.dirname(pluginJson);
+    const modules: string[] = [];
+    for await (const module of glob(`${folder}/module.{ts,tsx,js,jsx}`)) {
+      modules.push(path.resolve(module));
+    }
+    plugins.push(modules);
+  }
 
   return plugins.reduce<Record<string, string>>((result, modules) => {
     return modules.reduce((innerResult, module) => {

package/templates/common/_package.json

@@ -17,7 +17,7 @@
   "license": "Apache-2.0",
   "devDependencies": {
     "@grafana/eslint-config": "^10.0.0",
-    "@grafana/plugin-e2e": "^3.15.1",
+    "@grafana/plugin-e2e": "^3.15.2",
     "@grafana/sign-plugin": "^3.3.3",
     "@grafana/tsconfig": "^2.2.0",
     "@playwright/test": "^1.62.1",{{#if useExperimentalRspack}}
@@ -46,7 +46,6 @@
     "eslint-plugin-react-hooks": "^7.1.0",{{#if useExperimentalRspack}}
     "eslint-webpack-plugin": "^5.0.0",{{/if}}{{#unless useExperimentalRspack}}
     "fork-ts-checker-webpack-plugin": "^9.1.0",{{/unless}}
-    "glob": "^11.1.0",
     "identity-obj-proxy": "^3.0.0",
     "imports-loader": "^5.0.0",
     "intersection-observer": "^0.12.2",