@grafana/create-plugin 6.1.1 → 6.2.0-canary.2233.18644853669.0

package/CHANGELOG.md

@@ -1,15 +1,3 @@
-# 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/README.md

@@ -122,6 +122,45 @@ For more information see our [documentation](https://grafana.com/developers/plug
 
 ---
 
+## Add optional features to your existing plugin
+
+You can add optional features to your plugin using the `add` command. This allows you to enhance your plugin with additional capabilities without starting from scratch.
+
+### Add internationalization (i18n) support
+
+Add translation support to make your plugin available in multiple languages:
+
+```bash
+# Run this command from the root of your plugin
+cd ./my-plugin
+
+npx @grafana/create-plugin@latest add i18n
+```
+
+This will:
+
+- Update your `plugin.json` with the selected languages
+- Create locale folders and translation files
+- Add the necessary dependencies to `package.json`
+- Configure your docker-compose.yaml with the required feature toggle
+- Add i18n imports to your module file
+- Set up the i18n extraction script
+
+The command will prompt you to select which locales you want to support. You can choose from common locales like:
+
+- English (US) - `en-US`
+- Spanish (Spain) - `es-ES`
+- French (France) - `fr-FR`
+- German (Germany) - `de-DE`
+- Swedish (Sweden) - `sv-SE`
+- And more...
+
+You can also add custom locale codes during the interactive prompt.
+
+For more information about plugin internationalization, see our [documentation](https://grafana.com/developers/plugin-tools/how-to-guides/plugin-internationalization).
+
+---
+
 ## Contributing
 
 We are always grateful for contributions! See [CONTRIBUTING.md](../../CONTRIBUTING.md) for more information.

package/dist/additions/additions.js

@@ -0,0 +1,11 @@
+var defaultAdditions = {
+  additions: {
+    i18n: {
+      name: "i18n",
+      description: "Add internationalization (i18n) support to your plugin",
+      scriptPath: "./scripts/add-i18n.js"
+    }
+  }
+};
+
+export { defaultAdditions as default };

package/dist/additions/manager.js

@@ -0,0 +1,48 @@
+import { additionsDebug, printChanges } from './utils.js';
+import defaultAdditions from './additions.js';
+import { Context } from '../migrations/context.js';
+import { gitCommitNoVerify } from '../utils/utils.git.js';
+import { output } from '../utils/utils.console.js';
+import { formatFiles, flushChanges, installNPMDependencies } from '../migrations/utils.js';
+
+function getAvailableAdditions(additions = defaultAdditions.additions) {
+  return additions;
+}
+function getAdditionByName(name, additions = defaultAdditions.additions) {
+  return additions[name];
+}
+async function runAddition(addition, additionOptions = {}, runOptions = {}) {
+  const basePath = process.cwd();
+  output.log({
+    title: `Running addition: ${addition.name}`,
+    body: [addition.description]
+  });
+  try {
+    const context = new Context(basePath);
+    const updatedContext = await executeAddition(addition, context, additionOptions);
+    const shouldCommit = runOptions.commitChanges && updatedContext.hasChanges();
+    additionsDebug(`context for "${addition.name} (${addition.scriptPath})":`);
+    additionsDebug("%O", updatedContext.listChanges());
+    await formatFiles(updatedContext);
+    flushChanges(updatedContext);
+    printChanges(updatedContext, addition.name, addition);
+    installNPMDependencies(updatedContext);
+    if (shouldCommit) {
+      await gitCommitNoVerify(`chore: add ${addition.name} support via create-plugin`);
+    }
+    output.success({
+      title: `Successfully added ${addition.name} to your plugin.`
+    });
+  } catch (error) {
+    if (error instanceof Error) {
+      throw new Error(`Error running addition "${addition.name} (${addition.scriptPath})": ${error.message}`);
+    }
+    throw error;
+  }
+}
+async function executeAddition(addition, context, options = {}) {
+  const module = await import(addition.scriptPath);
+  return module.default(context, options);
+}
+
+export { executeAddition, getAdditionByName, getAvailableAdditions, runAddition };

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

@@ -0,0 +1,433 @@
+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;
+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 };

package/dist/additions/utils.js

@@ -0,0 +1,28 @@
+export { addDependenciesToPackageJson, flushChanges, formatFiles, installNPMDependencies } from '../migrations/utils.js';
+import chalk from 'chalk';
+import { debug } from '../utils/utils.cli.js';
+import { output } from '../utils/utils.console.js';
+
+const additionsDebug = debug.extend("additions");
+function printChanges(context, key, addition) {
+  const changes = context.listChanges();
+  const lines = [];
+  for (const [filePath, { changeType }] of Object.entries(changes)) {
+    if (changeType === "add") {
+      lines.push(`${chalk.green("ADD")} ${filePath}`);
+    } else if (changeType === "update") {
+      lines.push(`${chalk.yellow("UPDATE")} ${filePath}`);
+    } else if (changeType === "delete") {
+      lines.push(`${chalk.red("DELETE")} ${filePath}`);
+    }
+  }
+  output.addHorizontalLine("gray");
+  output.logSingleLine(`${key} (${addition.description})`);
+  if (lines.length === 0) {
+    output.logSingleLine("No changes were made");
+  } else {
+    output.log({ title: "Changes:", withPrefix: false, body: output.bulletList(lines) });
+  }
+}
+
+export { additionsDebug, printChanges };

package/dist/bin/run.js

@@ -4,8 +4,9 @@ import { update } from '../commands/update.command.js';
 import { migrate } from '../commands/migrate.command.js';
 import { version } from '../commands/version.command.js';
 import { provisioning } from '../commands/provisioning.command.js';
-import { isUnsupportedPlatform } from '../utils/utils.os.js';
+import { add } from '../commands/add.command.js';
 import { argv, commandName } from '../utils/utils.cli.js';
+import { isUnsupportedPlatform } from '../utils/utils.os.js';
 import { output } from '../utils/utils.console.js';
 
 if (isUnsupportedPlatform()) {
@@ -21,7 +22,8 @@ const commands = {
   generate,
   update,
   version,
-  provisioning
+  provisioning,
+  add
 };
 const command = commands[commandName] || "generate";
 command(argv);

package/dist/commands/add/prompts.js

@@ -0,0 +1,72 @@
+import Enquirer from 'enquirer';
+import { output } from '../../utils/utils.console.js';
+
+const COMMON_LOCALES = [
+  { name: "en-US", message: "English (US)" },
+  { name: "es-ES", message: "Spanish (Spain)" },
+  { name: "fr-FR", message: "French (France)" },
+  { name: "de-DE", message: "German (Germany)" },
+  { name: "zh-Hans", message: "Chinese (Simplified)" },
+  { name: "pt-BR", message: "Portuguese (Brazil)" },
+  { name: "sv-SE", message: "Swedish (Sweden)" },
+  { name: "nl-NL", message: "Dutch (Netherlands)" },
+  { name: "ja-JP", message: "Japanese (Japan)" },
+  { name: "it-IT", message: "Italian (Italy)" }
+];
+async function promptI18nOptions() {
+  const enquirer = new Enquirer();
+  output.log({
+    title: "Configure internationalization (i18n) for your plugin",
+    body: [
+      "Select the locales you want to support. At least one locale must be selected.",
+      "Use space to select, enter to continue."
+    ]
+  });
+  const localeChoices = COMMON_LOCALES.map((locale) => ({
+    name: locale.name,
+    message: locale.message,
+    value: locale.name
+  }));
+  let selectedLocales = [];
+  try {
+    const result = await enquirer.prompt({
+      type: "multiselect",
+      name: "locales",
+      message: "Select locales to support:",
+      choices: localeChoices,
+      initial: [0],
+      // Pre-select en-US by default
+      validate(value) {
+        if (value.length === 0) {
+          return "At least one locale must be selected";
+        }
+        return true;
+      }
+    });
+    selectedLocales = result.locales;
+  } catch (error) {
+    output.warning({ title: "Addition cancelled by user." });
+    process.exit(0);
+  }
+  try {
+    const addMoreResult = await enquirer.prompt({
+      type: "input",
+      name: "additionalLocales",
+      message: 'Enter additional locale codes (comma-separated, e.g., "ko-KR,ru-RU") or press enter to skip:'
+    });
+    const additionalLocalesInput = addMoreResult.additionalLocales;
+    if (additionalLocalesInput && additionalLocalesInput.trim()) {
+      const additionalLocales = additionalLocalesInput.split(",").map((locale) => locale.trim()).filter((locale) => locale.length > 0 && !selectedLocales.includes(locale));
+      selectedLocales.push(...additionalLocales);
+    }
+  } catch (error) {
+  }
+  output.log({
+    title: `Selected locales: ${selectedLocales.join(", ")}`
+  });
+  return {
+    locales: selectedLocales
+  };
+}
+
+export { promptI18nOptions };