@grafana/create-plugin 6.2.0-canary.2233.18586197736.0 → 6.2.0-canary.2233.18936109308.0

package/CHANGELOG.md

@@ -1,3 +1,67 @@
+# v6.1.5 (Tue Oct 28 2025)
+
+#### 🐛 Bug Fix
+
+- Create Plugin: Include EOF newline when setting root config [#2246](https://github.com/grafana/plugin-tools/pull/2246) ([@MattIPv4](https://github.com/MattIPv4))
+
+#### Authors: 1
+
+- Matt Cowley ([@MattIPv4](https://github.com/MattIPv4))
+
+---
+
+# v6.1.4 (Fri Oct 24 2025)
+
+#### 🐛 Bug Fix
+
+- Create Plugin: pin swc/core to 1.13.20 [#2243](https://github.com/grafana/plugin-tools/pull/2243) ([@jackw](https://github.com/jackw))
+
+#### Authors: 1
+
+- Jack Westbrook ([@jackw](https://github.com/jackw))
+
+---
+
+# v6.1.3 (Thu Oct 23 2025)
+
+#### 🐛 Bug Fix
+
+- Create Plugin: Scaffold workflows with versioned actions [#2234](https://github.com/grafana/plugin-tools/pull/2234) ([@jackw](https://github.com/jackw))
+
+#### Authors: 1
+
+- Jack Westbrook ([@jackw](https://github.com/jackw))
+
+---
+
+# v6.1.2 (Tue Oct 21 2025)
+
+#### 🐛 Bug Fix
+
+- Create Plugin: Remove cypress support [#2232](https://github.com/grafana/plugin-tools/pull/2232) ([@sunker](https://github.com/sunker))
+- Update dependency @grafana/e2e-selectors to v12.2.0 [#2205](https://github.com/grafana/plugin-tools/pull/2205) ([@renovate[bot]](https://github.com/renovate[bot]) [@leventebalogh](https://github.com/leventebalogh) [@mckn](https://github.com/mckn))
+
+#### Authors: 4
+
+- [@renovate[bot]](https://github.com/renovate[bot])
+- Erik Sundell ([@sunker](https://github.com/sunker))
+- Levente Balogh ([@leventebalogh](https://github.com/leventebalogh))
+- Marcus Andersson ([@mckn](https://github.com/mckn))
+
+---
+
+# v6.1.1 (Wed Oct 15 2025)
+
+#### 🐛 Bug Fix
+
+- Fix: Use proper install command for legacy plugin migrations [#2221](https://github.com/grafana/plugin-tools/pull/2221) ([@sunker]https://github.com/sunker))
+
+#### Authors: 1
+
+- Erik Sundell ([@sunker](https://github.com/sunker))
+
+---
+
 # v6.1.0 (Wed Oct 08 2025)
 
 #### 🚀 Enhancement

package/dist/additions/manager.js

@@ -11,6 +11,63 @@ function getAvailableAdditions(additions = defaultAdditions.additions) {
 function getAdditionByName(name, additions = defaultAdditions.additions) {
   return additions[name];
 }
+async function getAdditionFlags(addition) {
+  try {
+    const module = await import(addition.scriptPath);
+    return module.flags || [];
+  } catch (error) {
+    return [];
+  }
+}
+async function parseAdditionFlags(addition, argv) {
+  try {
+    const module = await import(addition.scriptPath);
+    if (module.parseFlags && typeof module.parseFlags === "function") {
+      return module.parseFlags(argv);
+    }
+    return {};
+  } catch (error) {
+    return {};
+  }
+}
+async function validateAdditionOptions(addition, options) {
+  const flags = await getAdditionFlags(addition);
+  if (!flags || flags.length === 0) {
+    return;
+  }
+  const missingFlags = [];
+  for (const flag of flags) {
+    if (flag.required) {
+      const value = options[flag.name];
+      if (value === void 0 || value === null || Array.isArray(value) && value.length === 0) {
+        missingFlags.push(flag.name);
+      }
+    }
+  }
+  if (missingFlags.length > 0) {
+    const flagDocs = flags.filter((f) => missingFlags.includes(f.name)).map((f) => `  --${f.name}: ${f.description}`);
+    throw new Error(
+      `Missing required flag${missingFlags.length > 1 ? "s" : ""}:
+
+` + flagDocs.join("\n") + `
+
+Example: npx @grafana/create-plugin add ${addition.name} --${missingFlags[0]}=value`
+    );
+  }
+}
+async function runAdditionByName(additionName, argv, runOptions = {}) {
+  const addition = getAdditionByName(additionName);
+  if (!addition) {
+    const availableAdditions = getAvailableAdditions();
+    const additionsList = Object.keys(availableAdditions);
+    throw new Error(`Unknown addition: ${additionName}
+
+Available additions: ${additionsList.join(", ")}`);
+  }
+  const options = await parseAdditionFlags(addition, argv);
+  await validateAdditionOptions(addition, options);
+  await runAddition(addition, options, runOptions);
+}
 async function runAddition(addition, additionOptions = {}, runOptions = {}) {
   const basePath = process.cwd();
   output.log({
@@ -45,4 +102,4 @@ async function executeAddition(addition, context, options = {}) {
   return module.default(context, options);
 }
 
-export { executeAddition, getAdditionByName, getAvailableAdditions, runAddition };
+export { executeAddition, getAdditionByName, getAdditionFlags, getAvailableAdditions, parseAdditionFlags, runAddition, runAdditionByName };

package/dist/additions/scripts/add-i18n.js

@@ -0,0 +1,445 @@
+import * as recast from 'recast';
+import { additionsDebug } from '../utils.js';
+import { coerce, gte } from 'semver';
+import { parseDocument, stringify } from 'yaml';
+import { addDependenciesToPackageJson } from '../../migrations/utils.js';
+
+const { builders } = recast.types;
+const flags = [
+  {
+    name: "locales",
+    description: "Comma-separated list of locales (e.g., en-US,es-ES)",
+    required: true
+  }
+];
+function parseFlags(argv) {
+  return {
+    locales: argv.locales ? argv.locales.split(",").map((l) => l.trim()) : []
+  };
+}
+function migrate(context, options = { locales: ["en-US"] }) {
+  const { locales } = options;
+  additionsDebug("Adding i18n support with locales:", locales);
+  if (isI18nConfigured(context)) {
+    additionsDebug("i18n already configured, skipping");
+    return context;
+  }
+  const needsBackwardCompatibility = checkNeedsBackwardCompatibility(context);
+  additionsDebug("Needs backward compatibility:", needsBackwardCompatibility);
+  if (!needsBackwardCompatibility) {
+    updateDockerCompose(context);
+  }
+  updatePluginJson(context, locales, needsBackwardCompatibility);
+  createLocaleFiles(context, locales);
+  addI18nDependency(context);
+  if (needsBackwardCompatibility) {
+    addSemverDependency(context);
+  }
+  updateEslintConfig(context);
+  addI18nInitialization(context, needsBackwardCompatibility);
+  if (needsBackwardCompatibility) {
+    createLoadResourcesFile(context);
+  }
+  addI18nextCli(context);
+  createI18nextConfig(context);
+  return context;
+}
+function isI18nConfigured(context) {
+  if (!context.doesFileExist("src/plugin.json")) {
+    return false;
+  }
+  const pluginJsonRaw = context.getFile("src/plugin.json");
+  if (!pluginJsonRaw) {
+    return false;
+  }
+  try {
+    const pluginJson = JSON.parse(pluginJsonRaw);
+    if (pluginJson.languages && Array.isArray(pluginJson.languages) && pluginJson.languages.length > 0) {
+      additionsDebug("Found languages in plugin.json, i18n already configured");
+      return true;
+    }
+  } catch (error) {
+    additionsDebug("Error parsing plugin.json:", error);
+  }
+  return false;
+}
+function checkNeedsBackwardCompatibility(context) {
+  const pluginJsonRaw = context.getFile("src/plugin.json");
+  if (!pluginJsonRaw) {
+    return false;
+  }
+  try {
+    const pluginJson = JSON.parse(pluginJsonRaw);
+    const currentGrafanaDep = pluginJson.dependencies?.grafanaDependency || ">=11.0.0";
+    const minVersion = coerce("12.1.0");
+    const currentVersion = coerce(currentGrafanaDep.replace(/^[><=]+/, ""));
+    if (currentVersion && minVersion && gte(currentVersion, minVersion)) {
+      return false;
+    }
+    return true;
+  } catch (error) {
+    additionsDebug("Error checking backward compatibility:", error);
+    return true;
+  }
+}
+function updateDockerCompose(context) {
+  if (!context.doesFileExist("docker-compose.yaml")) {
+    additionsDebug("docker-compose.yaml not found, skipping");
+    return;
+  }
+  const composeContent = context.getFile("docker-compose.yaml");
+  if (!composeContent) {
+    return;
+  }
+  try {
+    const composeDoc = parseDocument(composeContent);
+    const currentEnv = composeDoc.getIn(["services", "grafana", "environment"]);
+    if (!currentEnv) {
+      additionsDebug("No environment section found in docker-compose.yaml, skipping");
+      return;
+    }
+    if (typeof currentEnv === "object") {
+      const envMap = currentEnv;
+      const toggleValue = envMap.get("GF_FEATURE_TOGGLES_ENABLE");
+      if (toggleValue) {
+        const toggleStr = toggleValue.toString();
+        if (toggleStr.includes("localizationForPlugins")) {
+          additionsDebug("localizationForPlugins already in GF_FEATURE_TOGGLES_ENABLE");
+          return;
+        }
+        composeDoc.setIn(
+          ["services", "grafana", "environment", "GF_FEATURE_TOGGLES_ENABLE"],
+          `${toggleStr},localizationForPlugins`
+        );
+      } else {
+        composeDoc.setIn(["services", "grafana", "environment", "GF_FEATURE_TOGGLES_ENABLE"], "localizationForPlugins");
+      }
+      context.updateFile("docker-compose.yaml", stringify(composeDoc));
+      additionsDebug("Updated docker-compose.yaml with localizationForPlugins feature toggle");
+    }
+  } catch (error) {
+    additionsDebug("Error updating docker-compose.yaml:", error);
+  }
+}
+function updatePluginJson(context, locales, needsBackwardCompatibility) {
+  if (!context.doesFileExist("src/plugin.json")) {
+    additionsDebug("src/plugin.json not found, skipping");
+    return;
+  }
+  const pluginJsonRaw = context.getFile("src/plugin.json");
+  if (!pluginJsonRaw) {
+    return;
+  }
+  try {
+    const pluginJson = JSON.parse(pluginJsonRaw);
+    pluginJson.languages = locales;
+    if (!pluginJson.dependencies) {
+      pluginJson.dependencies = {};
+    }
+    const currentGrafanaDep = pluginJson.dependencies.grafanaDependency || ">=11.0.0";
+    const targetVersion = needsBackwardCompatibility ? "11.0.0" : "12.1.0";
+    const minVersion = coerce(targetVersion);
+    const currentVersion = coerce(currentGrafanaDep.replace(/^[><=]+/, ""));
+    if (!currentVersion || !minVersion || !gte(currentVersion, minVersion)) {
+      pluginJson.dependencies.grafanaDependency = `>=${targetVersion}`;
+      additionsDebug(`Updated grafanaDependency to >=${targetVersion}`);
+    }
+    context.updateFile("src/plugin.json", JSON.stringify(pluginJson, null, 2));
+    additionsDebug("Updated src/plugin.json with languages:", locales);
+  } catch (error) {
+    additionsDebug("Error updating src/plugin.json:", error);
+  }
+}
+function createLocaleFiles(context, locales) {
+  const pluginJsonRaw = context.getFile("src/plugin.json");
+  if (!pluginJsonRaw) {
+    additionsDebug("Cannot create locale files without plugin.json");
+    return;
+  }
+  try {
+    const pluginJson = JSON.parse(pluginJsonRaw);
+    const pluginId = pluginJson.id;
+    const pluginName = pluginJson.name || pluginId;
+    if (!pluginId) {
+      additionsDebug("No plugin ID found in plugin.json");
+      return;
+    }
+    const exampleTranslations = {
+      components: {
+        exampleComponent: {
+          title: `${pluginName} component title`,
+          description: "Example description"
+        }
+      },
+      config: {
+        title: `${pluginName} configuration`,
+        apiUrl: {
+          label: "API URL",
+          placeholder: "Enter API URL"
+        }
+      }
+    };
+    for (const locale of locales) {
+      const localePath = `src/locales/${locale}/${pluginId}.json`;
+      if (!context.doesFileExist(localePath)) {
+        context.addFile(localePath, JSON.stringify(exampleTranslations, null, 2));
+        additionsDebug(`Created ${localePath} with example translations`);
+      }
+    }
+  } catch (error) {
+    additionsDebug("Error creating locale files:", error);
+  }
+}
+function addI18nDependency(context) {
+  addDependenciesToPackageJson(context, { "@grafana/i18n": "12.2.2" }, {});
+  additionsDebug("Added @grafana/i18n dependency version 12.2.2");
+}
+function addSemverDependency(context) {
+  addDependenciesToPackageJson(context, { semver: "^7.6.0" }, { "@types/semver": "^7.5.0" });
+  additionsDebug("Added semver dependency for backward compatibility");
+}
+function addI18nextCli(context) {
+  addDependenciesToPackageJson(context, {}, { "i18next-cli": "^1.1.1" });
+  const packageJsonRaw = context.getFile("package.json");
+  if (!packageJsonRaw) {
+    return;
+  }
+  try {
+    const packageJson = JSON.parse(packageJsonRaw);
+    if (!packageJson.scripts) {
+      packageJson.scripts = {};
+    }
+    if (!packageJson.scripts["i18n-extract"]) {
+      packageJson.scripts["i18n-extract"] = "i18next-cli extract --sync-primary";
+      context.updateFile("package.json", JSON.stringify(packageJson, null, 2));
+      additionsDebug("Added i18n-extract script to package.json");
+    }
+  } catch (error) {
+    additionsDebug("Error adding i18n-extract script:", error);
+  }
+}
+function updateEslintConfig(context) {
+  if (!context.doesFileExist("eslint.config.mjs")) {
+    additionsDebug("eslint.config.mjs not found, skipping");
+    return;
+  }
+  const eslintConfigRaw = context.getFile("eslint.config.mjs");
+  if (!eslintConfigRaw) {
+    return;
+  }
+  if (eslintConfigRaw.includes("@grafana/eslint-plugin-plugins")) {
+    additionsDebug("ESLint i18n rule already configured");
+    return;
+  }
+  try {
+    const ast = recast.parse(eslintConfigRaw, {
+      parser: require("recast/parsers/babel-ts")
+    });
+    const imports = ast.program.body.filter((node) => node.type === "ImportDeclaration");
+    const lastImport = imports[imports.length - 1];
+    if (lastImport) {
+      const pluginImport = builders.importDeclaration(
+        [builders.importDefaultSpecifier(builders.identifier("grafanaPluginsPlugin"))],
+        builders.literal("@grafana/eslint-plugin-plugins")
+      );
+      const lastImportIndex = ast.program.body.indexOf(lastImport);
+      ast.program.body.splice(lastImportIndex + 1, 0, pluginImport);
+    }
+    recast.visit(ast, {
+      visitCallExpression(path) {
+        if (path.node.callee.name === "defineConfig" && path.node.arguments[0]?.type === "ArrayExpression") {
+          const configArray = path.node.arguments[0];
+          const pluginsConfig = builders.objectExpression([
+            builders.property(
+              "init",
+              builders.identifier("plugins"),
+              builders.objectExpression([
+                builders.property(
+                  "init",
+                  builders.literal("grafanaPlugins"),
+                  builders.identifier("grafanaPluginsPlugin")
+                )
+              ])
+            ),
+            builders.property(
+              "init",
+              builders.identifier("rules"),
+              builders.objectExpression([
+                builders.property(
+                  "init",
+                  builders.literal("grafanaPlugins/no-untranslated-strings"),
+                  builders.literal("warn")
+                )
+              ])
+            )
+          ]);
+          configArray.elements.push(pluginsConfig);
+        }
+        this.traverse(path);
+      }
+    });
+    const output = recast.print(ast, {
+      tabWidth: 2,
+      trailingComma: true,
+      lineTerminator: "\n"
+    }).code;
+    context.updateFile("eslint.config.mjs", output);
+    additionsDebug("Updated eslint.config.mjs with i18n linting rules");
+  } catch (error) {
+    additionsDebug("Error updating eslint.config.mjs:", error);
+  }
+}
+function createI18nextConfig(context) {
+  if (context.doesFileExist("i18next.config.ts")) {
+    additionsDebug("i18next.config.ts already exists, skipping");
+    return;
+  }
+  const pluginJsonRaw = context.getFile("src/plugin.json");
+  if (!pluginJsonRaw) {
+    additionsDebug("Cannot create i18next.config.ts without plugin.json");
+    return;
+  }
+  try {
+    const pluginJson = JSON.parse(pluginJsonRaw);
+    const pluginId = pluginJson.id;
+    if (!pluginId) {
+      additionsDebug("No plugin ID found in plugin.json");
+      return;
+    }
+    const i18nextConfig = `import { defineConfig } from 'i18next-cli';
+import pluginJson from './src/plugin.json';
+
+export default defineConfig({
+  locales: pluginJson.languages,
+  extract: {
+    input: ['src/**/*.{tsx,ts}'],
+    output: 'src/locales/{{language}}/{{namespace}}.json',
+    defaultNS: pluginJson.id,
+    functions: ['t', '*.t'],
+    transComponents: ['Trans'],
+  },
+});
+`;
+    context.addFile("i18next.config.ts", i18nextConfig);
+    additionsDebug("Created i18next.config.ts");
+  } catch (error) {
+    additionsDebug("Error creating i18next.config.ts:", error);
+  }
+}
+function addI18nInitialization(context, needsBackwardCompatibility) {
+  const moduleTsPath = context.doesFileExist("src/module.ts") ? "src/module.ts" : context.doesFileExist("src/module.tsx") ? "src/module.tsx" : null;
+  if (!moduleTsPath) {
+    additionsDebug("No module.ts or module.tsx found, skipping i18n initialization");
+    return;
+  }
+  const moduleContent = context.getFile(moduleTsPath);
+  if (!moduleContent) {
+    return;
+  }
+  if (moduleContent.includes("initPluginTranslations")) {
+    additionsDebug("i18n already initialized in module file");
+    return;
+  }
+  try {
+    const ast = recast.parse(moduleContent, {
+      parser: require("recast/parsers/babel-ts")
+    });
+    const imports = [];
+    imports.push(
+      builders.importDeclaration(
+        [builders.importSpecifier(builders.identifier("initPluginTranslations"))],
+        builders.literal("@grafana/i18n")
+      )
+    );
+    imports.push(
+      builders.importDeclaration(
+        [builders.importDefaultSpecifier(builders.identifier("pluginJson"))],
+        builders.literal("plugin.json")
+      )
+    );
+    if (needsBackwardCompatibility) {
+      imports.push(
+        builders.importDeclaration(
+          [builders.importSpecifier(builders.identifier("config"))],
+          builders.literal("@grafana/runtime")
+        )
+      );
+      imports.push(
+        builders.importDeclaration(
+          [builders.importDefaultSpecifier(builders.identifier("semver"))],
+          builders.literal("semver")
+        )
+      );
+      imports.push(
+        builders.importDeclaration(
+          [builders.importSpecifier(builders.identifier("loadResources"))],
+          builders.literal("./loadResources")
+        )
+      );
+    }
+    const firstImportIndex = ast.program.body.findIndex((node) => node.type === "ImportDeclaration");
+    if (firstImportIndex !== -1) {
+      ast.program.body.splice(firstImportIndex + 1, 0, ...imports);
+    } else {
+      ast.program.body.unshift(...imports);
+    }
+    const i18nInitCode = needsBackwardCompatibility ? `// Before Grafana version 12.1.0 the plugin is responsible for loading translation resources
+// In Grafana version 12.1.0 and later Grafana is responsible for loading translation resources
+const loaders = semver.lt(config?.buildInfo?.version, '12.1.0') ? [loadResources] : [];
+
+await initPluginTranslations(pluginJson.id, loaders);` : `await initPluginTranslations(pluginJson.id);`;
+    const initAst = recast.parse(i18nInitCode, {
+      parser: require("recast/parsers/babel-ts")
+    });
+    const lastImportIndex = ast.program.body.findLastIndex((node) => node.type === "ImportDeclaration");
+    if (lastImportIndex !== -1) {
+      ast.program.body.splice(lastImportIndex + 1, 0, ...initAst.program.body);
+    } else {
+      ast.program.body.unshift(...initAst.program.body);
+    }
+    const output = recast.print(ast, {
+      tabWidth: 2,
+      trailingComma: true,
+      lineTerminator: "\n"
+    }).code;
+    context.updateFile(moduleTsPath, output);
+    additionsDebug(`Updated ${moduleTsPath} with i18n initialization`);
+  } catch (error) {
+    additionsDebug("Error updating module file:", error);
+  }
+}
+function createLoadResourcesFile(context) {
+  const loadResourcesPath = "src/loadResources.ts";
+  if (context.doesFileExist(loadResourcesPath)) {
+    additionsDebug("loadResources.ts already exists, skipping");
+    return;
+  }
+  const pluginJsonRaw = context.getFile("src/plugin.json");
+  if (!pluginJsonRaw) {
+    additionsDebug("Cannot create loadResources.ts without plugin.json");
+    return;
+  }
+  const loadResourcesContent = `import { LANGUAGES, ResourceLoader, Resources } from '@grafana/i18n';
+import pluginJson from 'plugin.json';
+
+const resources = LANGUAGES.reduce<Record<string, () => Promise<{ default: Resources }>>>((acc, lang) => {
+  acc[lang.code] = async () => await import(\`./locales/\${lang.code}/\${pluginJson.id}.json\`);
+  return acc;
+}, {});
+
+export const loadResources: ResourceLoader = async (resolvedLanguage: string) => {
+  try {
+    const translation = await resources[resolvedLanguage]();
+    return translation.default;
+  } catch (error) {
+    // This makes sure that the plugin doesn't crash when the resolved language in Grafana isn't supported by the plugin
+    console.error(\`The plugin '\${pluginJson.id}' doesn't support the language '\${resolvedLanguage}'\`, error);
+    return {};
+  }
+};
+`;
+  context.addFile(loadResourcesPath, loadResourcesContent);
+  additionsDebug("Created src/loadResources.ts for backward compatibility");
+}
+
+export { migrate as default, flags, parseFlags };

package/dist/commands/add.command.js

@@ -1,49 +1,17 @@
-import { getAvailableAdditions, getAdditionByName, runAddition } from '../additions/manager.js';
+import { runAdditionByName, getAvailableAdditions, getAdditionFlags } from '../additions/manager.js';
 import { isGitDirectory, isGitDirectoryClean } from '../utils/utils.git.js';
 import { isPluginDirectory } from '../utils/utils.plugin.js';
 import { output } from '../utils/utils.console.js';
-import { promptI18nOptions } from './add/prompts.js';
 
 const add = async (argv) => {
   const subCommand = argv._[1];
   if (!subCommand) {
-    const availableAdditions = getAvailableAdditions();
-    const additionsList = Object.values(availableAdditions).map(
-      (addition2) => `${addition2.name} - ${addition2.description}`
-    );
-    output.error({
-      title: "No addition specified",
-      body: [
-        "Usage: npx @grafana/create-plugin add <addition-name>",
-        "",
-        "Available additions:",
-        ...output.bulletList(additionsList)
-      ]
-    });
+    await showAdditionsHelp();
     process.exit(1);
   }
   await performPreAddChecks(argv);
-  const addition = getAdditionByName(subCommand);
-  if (!addition) {
-    const availableAdditions = getAvailableAdditions();
-    const additionsList = Object.values(availableAdditions).map((addition2) => addition2.name);
-    output.error({
-      title: `Unknown addition: ${subCommand}`,
-      body: ["Available additions:", ...output.bulletList(additionsList)]
-    });
-    process.exit(1);
-  }
   try {
-    let options = {};
-    switch (addition.name) {
-      case "i18n":
-        options = await promptI18nOptions();
-        break;
-      default:
-        break;
-    }
-    const commitChanges = argv.commit;
-    await runAddition(addition, options, { commitChanges });
+    await runAdditionByName(subCommand, argv, { commitChanges: argv.commit });
   } catch (error) {
     if (error instanceof Error) {
       output.error({
@@ -54,6 +22,32 @@ const add = async (argv) => {
     process.exit(1);
   }
 };
+async function showAdditionsHelp() {
+  const availableAdditions = getAvailableAdditions();
+  const additionsList = await Promise.all(
+    Object.values(availableAdditions).map(async (addition) => {
+      let info = `${addition.name} - ${addition.description}`;
+      const flags = await getAdditionFlags(addition);
+      if (flags.length > 0) {
+        const flagDocs = flags.map((flag) => {
+          const req = flag.required ? " (required)" : " (optional)";
+          return `  --${flag.name}: ${flag.description}${req}`;
+        });
+        info += "\n" + flagDocs.join("\n");
+      }
+      return info;
+    })
+  );
+  output.error({
+    title: "No addition specified",
+    body: [
+      "Usage: npx @grafana/create-plugin add <addition-name> [options]",
+      "",
+      "Available additions:",
+      ...output.bulletList(additionsList)
+    ]
+  });
+}
 async function performPreAddChecks(argv) {
   if (!await isGitDirectory() && !argv.force) {
     output.error({

package/dist/constants.js

@@ -1,5 +1,5 @@
-import path from 'node:path';
 import { fileURLToPath } from 'node:url';
+import path from 'node:path';
 
 const __dirname = fileURLToPath(new URL(".", import.meta.url));
 const IS_DEV = process.env.CREATE_PLUGIN_DEV !== void 0;
@@ -32,18 +32,10 @@ const EXTRA_TEMPLATE_VARIABLES = {
 const DEFAULT_FEATURE_FLAGS = {
   useReactRouterV6: true,
   bundleGrafanaUI: false,
-  usePlaywright: true,
   useExperimentalRspack: false,
   useExperimentalUpdates: true
 };
-const GRAFANA_FE_PACKAGES = [
-  "@grafana/data",
-  "@grafana/e2e-selectors",
-  "@grafana/e2e",
-  "@grafana/runtime",
-  "@grafana/schema",
-  "@grafana/ui"
-];
+const GRAFANA_FE_PACKAGES = ["@grafana/data", "@grafana/runtime", "@grafana/schema", "@grafana/ui"];
 const MIGRATION_CONFIG = {
   // Files that should be overriden during a migration.
   // (paths are relative to the scaffolded projects root)