@retailcrm/embed-ui 0.9.21 → 0.9.22-alpha.1

package/bin/embed-ui.mjs

@@ -0,0 +1,2681 @@
+#!/usr/bin/env node
+import { createInterface } from "node:readline/promises";
+import { execFileSync } from "node:child_process";
+import fs from "node:fs";
+import path from "node:path";
+import { pathToFileURL } from "node:url";
+import process$1 from "node:process";
+import yargs from "yargs";
+import { randomUUID } from "node:crypto";
+const PACKAGE_MANAGERS = ["yarn", "npm", "pnpm", "bun"];
+const HELP_TEXT = `Usage:
+  npx @retailcrm/embed-ui [target] [version] [options]
+  npx @retailcrm/embed-ui init [target] [options]
+
+Options:
+  -t, --target <path>     Target path (default: current directory)
+  -v, --version <ver>     Target version. If omitted, latest npm version is used
+      --exact             Use exact version instead of range
+      --dry-run           Show changes without writing package.json
+      --add               Add selected embed-ui packages into one package.json
+      --packages <list>   Comma-separated package ids or names for --add/init
+      --cwd <path>        Project working directory for init
+      --package-manager   Package manager for init installs
+      --interactive       Ask init questions in TTY instead of using every default
+      --no-install        Do not run package manager install in init mode
+      --no-configs        Do not create root TypeScript, Vite, ESLint and env config files
+      --force-deps        Replace incompatible existing init dependencies
+      --fix-sections      Move init dependencies to expected package.json sections
+      --no-agents         Do not create or update AGENTS.md in init mode
+      --no-mcp            Do not add package MCP instructions in init mode
+      --mcp-client-configs Comma-separated MCP client configs to create (cursor,junie,vscode)
+  -h, --help              Show this help
+
+Examples:
+  npx @retailcrm/embed-ui
+  npx @retailcrm/embed-ui --version 0.9.11
+  npx @retailcrm/embed-ui ./my-project 0.9.11
+  npx @retailcrm/embed-ui --target ./my-project --dry-run
+  npx @retailcrm/embed-ui --add
+  npx @retailcrm/embed-ui --add --packages components,contexts
+  npx @retailcrm/embed-ui init ./web --package-manager yarn
+  npx @retailcrm/embed-ui init --interactive
+`;
+const isSemverLike = (value) => /^v?\d+\.\d+\.\d+/.test(value);
+const stripLeadingV = (value) => value.replace(/^v/, "");
+const parsePackageList = (value) => value.split(",").map((entry) => entry.trim()).filter(Boolean);
+const parseInitArgs = (argv) => {
+  const normalizedArgv = argv.map((argument) => {
+    if (argument === "--no-dirs") {
+      return "--no-dirs-enabled";
+    }
+    if (argument === "--no-template") {
+      return "--no-template-enabled";
+    }
+    return argument;
+  });
+  const parsed = yargs(normalizedArgv).scriptName("embed-ui").usage("Usage: $0 init [target] [options]").help(false).version(false).exitProcess(false).strictOptions().parserConfiguration({
+    "camel-case-expansion": true,
+    "boolean-negation": true
+  }).option("cwd", {
+    type: "string",
+    default: process$1.cwd(),
+    describe: "Project working directory"
+  }).option("help", {
+    alias: "h",
+    type: "boolean"
+  }).option("target", {
+    alias: "t",
+    type: "string",
+    describe: "Frontend target directory relative to cwd"
+  }).option("version", {
+    alias: "v",
+    type: "string",
+    coerce: stripLeadingV,
+    describe: "Target package version"
+  }).option("packages", {
+    type: "string",
+    coerce: parsePackageList,
+    describe: "Comma-separated init package ids or names"
+  }).option("with", {
+    type: "string",
+    coerce: parsePackageList,
+    describe: "Additional published package ids or names"
+  }).option("package-manager", {
+    type: "string",
+    choices: PACKAGE_MANAGERS,
+    describe: "Package manager used for install"
+  }).option("dirs", {
+    type: "string",
+    coerce: parsePackageList,
+    describe: "Comma-separated directory presets"
+  }).option("src-dir", {
+    type: "string",
+    describe: "Frontend source root relative to cwd"
+  }).option("template", {
+    type: "string",
+    default: "order-card",
+    describe: "Starter template name"
+  }).option("page-code", {
+    type: "string",
+    default: "settings",
+    describe: "Starter embedded page code"
+  }).option("widget-target", {
+    type: "string",
+    default: "order/card:common.after",
+    describe: "Starter widget target"
+  }).option("dry-run", { type: "boolean", default: false }).option("exact", { type: "boolean", default: false }).option("interactive", { type: "boolean", default: false }).option("install", { type: "boolean", default: true }).option("force", { type: "boolean", default: false }).option("force-deps", { type: "boolean", default: false }).option("fix-sections", { type: "boolean", default: false }).option("force-files", { type: "boolean", default: false }).option("configs", { type: "boolean", default: true }).option("dirs-enabled", { type: "boolean", default: true }).option("template-enabled", { type: "boolean", default: true }).option("agents", { type: "boolean", default: true }).option("force-agents", { type: "boolean", default: false }).option("agents-only", { type: "boolean", default: false }).option("mcp", { type: "boolean", default: true }).option("force-mcp", { type: "boolean", default: false }).option("mcp-client-configs", {
+    type: "string",
+    coerce: parsePackageList,
+    describe: "Comma-separated MCP client config ids"
+  }).parseSync();
+  if (parsed.help || parsed.h) {
+    console.log(HELP_TEXT);
+    process$1.exit(0);
+  }
+  const positionals = parsed._.map(String);
+  if (positionals.length > 1) {
+    throw new Error("Too many positional arguments");
+  }
+  if (!parsed.mcp && parsed.mcpClientConfigs?.length) {
+    throw new Error("Option --mcp-client-configs cannot be used together with --no-mcp");
+  }
+  return {
+    command: "init",
+    cwd: path.resolve(process$1.cwd(), parsed.cwd),
+    target: parsed.target ?? positionals[0] ?? null,
+    version: parsed.version ?? null,
+    dryRun: parsed.dryRun,
+    exact: parsed.exact,
+    packages: parsed.packages ?? null,
+    with: parsed.with ?? null,
+    packageManager: parsed.packageManager ?? null,
+    interactive: parsed.interactive,
+    noInstall: !parsed.install,
+    force: parsed.force,
+    forceDeps: parsed.forceDeps,
+    fixSections: parsed.fixSections,
+    forceFiles: parsed.forceFiles,
+    noConfigs: !parsed.configs,
+    noDirs: !parsed.dirsEnabled,
+    dirs: parsed.dirs ?? null,
+    srcDir: parsed.srcDir ?? null,
+    noTemplate: !parsed.templateEnabled,
+    template: parsed.template,
+    pageCode: parsed.pageCode,
+    widgetTarget: parsed.widgetTarget,
+    noAgents: !parsed.agents,
+    forceAgents: parsed.forceAgents,
+    agentsOnly: parsed.agentsOnly,
+    noMcp: !parsed.mcp,
+    forceMcp: parsed.forceMcp,
+    mcpClientConfigs: parsed.mcpClientConfigs ?? null
+  };
+};
+const parseArgs = (argv) => {
+  if (argv[0] === "init") {
+    return parseInitArgs(argv.slice(1));
+  }
+  const parsed = yargs(argv).scriptName("embed-ui").usage("Usage: $0 [target] [version] [options]").help(false).version(false).exitProcess(false).strictOptions().option("target", {
+    alias: "t",
+    type: "string",
+    default: process$1.cwd()
+  }).option("help", {
+    alias: "h",
+    type: "boolean"
+  }).option("version", {
+    alias: "v",
+    type: "string",
+    coerce: stripLeadingV
+  }).option("dry-run", { type: "boolean", default: false }).option("exact", { type: "boolean", default: false }).option("add", { type: "boolean", default: false }).option("packages", {
+    type: "string",
+    coerce: parsePackageList
+  }).parseSync();
+  if (parsed.help || parsed.h) {
+    console.log(HELP_TEXT);
+    process$1.exit(0);
+  }
+  const positionals = parsed._.map(String);
+  if (positionals.length > 2) {
+    throw new Error("Too many positional arguments");
+  }
+  const options = {
+    command: "update",
+    target: path.resolve(process$1.cwd(), parsed.target),
+    version: parsed.version ?? null,
+    dryRun: parsed.dryRun,
+    exact: parsed.exact,
+    add: parsed.add,
+    packages: parsed.packages ?? null
+  };
+  if (positionals.length >= 1) {
+    const first = positionals[0];
+    if (!options.version && isSemverLike(first)) {
+      options.version = stripLeadingV(first);
+    } else {
+      options.target = path.resolve(process$1.cwd(), first);
+    }
+  }
+  if (positionals.length === 2) {
+    if (options.version) {
+      throw new Error("Version is already specified");
+    }
+    options.version = stripLeadingV(positionals[1]);
+  }
+  if (options.packages && !options.add) {
+    throw new Error("Option --packages can only be used together with --add");
+  }
+  return options;
+};
+const TARGET_SECTIONS = [
+  "dependencies",
+  "devDependencies",
+  "peerDependencies",
+  "optionalDependencies"
+];
+const ROOT_PACKAGE = "@retailcrm/embed-ui";
+const DEFAULT_INIT_PACKAGE_IDS = ["embed-ui", "components", "contexts", "types", "endpoint"];
+const INSTALLABLE_PACKAGES = [
+  {
+    id: "embed-ui",
+    name: ROOT_PACKAGE,
+    section: "dependencies",
+    description: "Базовый пакет с общим API и согласованными v1-зависимостями."
+  },
+  {
+    id: "components",
+    name: "@retailcrm/embed-ui-v1-components",
+    section: "dependencies",
+    description: "UI-компоненты для host/remote приложений.",
+    hooks: [
+      {
+        type: "agents",
+        binName: "embed-ui-v1-components",
+        command: "init-agents",
+        failureMode: "advisory"
+      }
+    ]
+  },
+  {
+    id: "contexts",
+    name: "@retailcrm/embed-ui-v1-contexts",
+    section: "dependencies",
+    description: "Реактивные контексты RetailCRM JS API."
+  },
+  {
+    id: "types",
+    name: "@retailcrm/embed-ui-v1-types",
+    section: "dependencies",
+    description: "Базовые type declarations для RetailCRM JS API."
+  },
+  {
+    id: "testing",
+    name: "@retailcrm/embed-ui-v1-testing",
+    section: "devDependencies",
+    description: "Вспомогательные утилиты и типы для тестов интеграций."
+  },
+  {
+    id: "endpoint",
+    name: "@retailcrm/embed-ui-v1-endpoint",
+    section: "dependencies",
+    description: "Endpoint API для интеграций в RetailCRM.",
+    hooks: [
+      {
+        type: "agents",
+        binName: "embed-ui-v1-endpoint",
+        command: "init-agents",
+        failureMode: "advisory",
+        requiresMcp: true
+      },
+      {
+        type: "config",
+        binName: "embed-ui-v1-endpoint",
+        command: "init-config",
+        failureMode: "advisory",
+        requiresMcp: true
+      }
+    ]
+  }
+];
+const resolveLatestVersion = () => {
+  const output = execFileSync(
+    "npm",
+    ["view", ROOT_PACKAGE, "version"],
+    {
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "pipe"]
+    }
+  ).trim();
+  if (!output) {
+    throw new Error(`Cannot resolve latest version for ${ROOT_PACKAGE}`);
+  }
+  return output;
+};
+const isTargetPackage = (name) => name === ROOT_PACKAGE || name.startsWith(`${ROOT_PACKAGE}-`);
+const createRange = (version, exact) => exact ? version : `^${version}`;
+const formatRange = (currentRange, nextVersion, exact) => {
+  if (exact) {
+    return nextVersion;
+  }
+  if (currentRange.startsWith("workspace:")) {
+    return currentRange;
+  }
+  if (currentRange.startsWith("~")) {
+    return `~${nextVersion}`;
+  }
+  if (currentRange.startsWith("^")) {
+    return `^${nextVersion}`;
+  }
+  return `^${nextVersion}`;
+};
+const findDependencySection = (packageJson, packageName) => {
+  for (const section of TARGET_SECTIONS) {
+    const dependencyMap = packageJson[section];
+    if (dependencyMap && typeof dependencyMap === "object" && packageName in dependencyMap) {
+      return section;
+    }
+  }
+  return null;
+};
+const updatePackageJson = (packageJson, version, exact) => {
+  const updates = [];
+  for (const section of TARGET_SECTIONS) {
+    const dependencyMap = packageJson[section];
+    if (!dependencyMap || typeof dependencyMap !== "object") {
+      continue;
+    }
+    for (const [name, currentRange] of Object.entries(dependencyMap)) {
+      if (!isTargetPackage(name) || typeof currentRange !== "string") {
+        continue;
+      }
+      const nextRange = formatRange(currentRange, version, exact);
+      if (nextRange === currentRange) {
+        continue;
+      }
+      dependencyMap[name] = nextRange;
+      updates.push({
+        type: "update",
+        section,
+        name,
+        currentRange,
+        nextRange
+      });
+    }
+  }
+  return updates;
+};
+const resolveInstallPackages = (tokens) => {
+  const selectedPackages = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const token of tokens) {
+    const normalized = token.trim();
+    if (!normalized) {
+      continue;
+    }
+    const numericIndex = Number(normalized);
+    const selectedPackage = Number.isInteger(numericIndex) && numericIndex >= 1 && numericIndex <= INSTALLABLE_PACKAGES.length ? INSTALLABLE_PACKAGES[numericIndex - 1] : INSTALLABLE_PACKAGES.find((entry) => entry.id === normalized || entry.name === normalized);
+    if (!selectedPackage) {
+      const supported = INSTALLABLE_PACKAGES.map((entry, index) => `${index + 1}/${entry.id}/${entry.name}`).join(", ");
+      throw new Error(`Unknown add target "${normalized}". Supported values: ${supported}`);
+    }
+    if (seen.has(selectedPackage.name)) {
+      continue;
+    }
+    seen.add(selectedPackage.name);
+    selectedPackages.push(selectedPackage);
+  }
+  return selectedPackages;
+};
+const installPackages = (packageJson, packages, version, exact) => {
+  const updates = [];
+  for (const selectedPackage of packages) {
+    const section = findDependencySection(packageJson, selectedPackage.name) ?? selectedPackage.section;
+    const dependencyMap = packageJson[section] ?? {};
+    if (!(section in packageJson)) {
+      packageJson[section] = dependencyMap;
+    }
+    const currentRange = dependencyMap[selectedPackage.name];
+    const nextRange = typeof currentRange === "string" ? formatRange(currentRange, version, exact) : createRange(version, exact);
+    if (currentRange === nextRange) {
+      continue;
+    }
+    dependencyMap[selectedPackage.name] = nextRange;
+    updates.push({
+      type: typeof currentRange === "string" ? "update" : "install",
+      section,
+      name: selectedPackage.name,
+      currentRange: typeof currentRange === "string" ? currentRange : null,
+      nextRange
+    });
+  }
+  return updates;
+};
+const promptForInstallSelection = async (packageJson) => {
+  if (!process$1.stdin.isTTY || !process$1.stdout.isTTY) {
+    throw new Error("Interactive add mode requires a TTY. Use --packages to select packages explicitly.");
+  }
+  console.log("Выберите пакеты для установки в текущий package.json:");
+  for (const [index, selectedPackage] of INSTALLABLE_PACKAGES.entries()) {
+    const currentSection = findDependencySection(packageJson, selectedPackage.name);
+    const installedHint = currentSection ? ` Уже есть в ${currentSection}.` : "";
+    console.log(`  ${index + 1}. ${selectedPackage.name} (${selectedPackage.id})`);
+    console.log(`     ${selectedPackage.description} Раздел по умолчанию: ${selectedPackage.section}.${installedHint}`);
+  }
+  const readline = createInterface({
+    input: process$1.stdin,
+    output: process$1.stdout
+  });
+  try {
+    while (true) {
+      const answer = await readline.question(
+        "Введите номера, ids или имена пакетов через запятую (например: 1,3 или components,types): "
+      );
+      const tokens = parsePackageList(answer);
+      if (tokens.length === 0) {
+        return [];
+      }
+      try {
+        return resolveInstallPackages(tokens);
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        console.error(message);
+      }
+    }
+  } finally {
+    readline.close();
+  }
+};
+const DEFAULT_INDENT = "  ";
+const DEFAULT_NEWLINE = "\n";
+const INIT_RUNTIME_DEPENDENCIES = [
+  { name: "@omnicajs/vue-remote", range: "^0.2.23" },
+  { name: "pinia", range: "^2.2" },
+  { name: "vue", range: "^3.5" },
+  { name: "vue-i18n", range: "^11" }
+];
+const INIT_DEV_DEPENDENCIES = [
+  { name: "@eslint/js", range: "^9.39" },
+  { name: "@intlify/eslint-plugin-vue-i18n", range: "~4.3.0" },
+  { name: "@intlify/unplugin-vue-i18n", range: "^11.1" },
+  { name: "@omnicajs/eslint-plugin-dependencies", range: "^0.0.2" },
+  { name: "@types/node", range: "^22.19" },
+  { name: "@vitejs/plugin-vue", range: "^6.0" },
+  { name: "@vue/language-server", range: "^3.2" },
+  { name: "eslint", range: "^9.39" },
+  { name: "eslint-plugin-vue", range: "^10.9" },
+  { name: "globals", range: "^16.5" },
+  { name: "less", range: "^4.6" },
+  { name: "typescript", range: "^5.9" },
+  { name: "typescript-eslint", range: "^8.59" },
+  { name: "vite", range: "^7.3" },
+  { name: "vite-svg-loader", range: "^5.1" },
+  { name: "vue-eslint-parser", range: "^10.4" }
+];
+const I18N_RUNTIME_DEPENDENCY = "vue-i18n";
+const hasExistingDependency = (packageJson, name) => findDependencySection(packageJson, name) !== null;
+const detectFormatting = (source) => {
+  const newline = source.includes("\r\n") ? "\r\n" : DEFAULT_NEWLINE;
+  const indentMatch = source.match(/\n([ \t]+)"/);
+  return {
+    indent: indentMatch?.[1] ?? DEFAULT_INDENT,
+    newline,
+    trailingNewline: source.endsWith("\n") || source.endsWith("\r\n")
+  };
+};
+const serializePackageJson = (packageJson, formatting) => {
+  const serialized = JSON.stringify(packageJson, null, formatting.indent).replace(/\n/g, formatting.newline);
+  return formatting.trailingNewline ? `${serialized}${formatting.newline}` : serialized;
+};
+const readPackageJson = (packageJsonPath) => {
+  const source = fs.readFileSync(packageJsonPath, "utf8");
+  return {
+    formatting: detectFormatting(source),
+    packageJson: JSON.parse(source)
+  };
+};
+const writePackageJson = (packageJsonPath, packageJson, formatting) => {
+  fs.writeFileSync(packageJsonPath, serializePackageJson(packageJson, formatting), "utf8");
+};
+const readOrCreatePackageJson = (packageJsonPath) => {
+  if (fs.existsSync(packageJsonPath)) {
+    return {
+      created: false,
+      ...readPackageJson(packageJsonPath)
+    };
+  }
+  return {
+    created: true,
+    formatting: {
+      indent: DEFAULT_INDENT,
+      newline: DEFAULT_NEWLINE,
+      trailingNewline: true
+    },
+    packageJson: {
+      name: "retailcrm-extension-frontend",
+      private: true,
+      type: "module",
+      scripts: {
+        build: "vite build",
+        eslint: "eslint .",
+        "eslint:fix": "eslint --fix ."
+      },
+      dependencies: {},
+      devDependencies: {}
+    }
+  };
+};
+const ensureObjectField = (object, field) => {
+  if (!object[field] || typeof object[field] !== "object" || Array.isArray(object[field])) {
+    object[field] = {};
+  }
+  return object[field];
+};
+const resolveRangeMajor$1 = (range) => {
+  const match = range.match(/\d+/u);
+  return match ? Number(match[0]) : null;
+};
+const isCompatibleRange = (currentRange, expectedRange) => {
+  const currentMajor = resolveRangeMajor$1(currentRange);
+  const expectedMajor = resolveRangeMajor$1(expectedRange);
+  return currentMajor !== null && expectedMajor !== null && currentMajor === expectedMajor;
+};
+const setMissingScript = (packageJson, name, command, changes) => {
+  const scripts = ensureObjectField(packageJson, "scripts");
+  if (scripts[name] === command) {
+    return;
+  }
+  if (typeof scripts[name] === "string") {
+    changes.warnings.push(`script "${name}" already exists and will not be overwritten`);
+    return;
+  }
+  scripts[name] = command;
+  changes.packageJson.push({
+    type: "script",
+    name,
+    nextRange: command
+  });
+};
+const setDependency = (packageJson, section, name, range, changes, options = {}) => {
+  let currentSection = findDependencySection(packageJson, name);
+  if (currentSection && currentSection !== section) {
+    if (options.fixSections) {
+      const previousSection = currentSection;
+      const currentDependencyMap = packageJson[currentSection];
+      const nextDependencyMap = ensureObjectField(packageJson, section);
+      nextDependencyMap[name] = currentDependencyMap[name];
+      delete currentDependencyMap[name];
+      currentSection = section;
+      changes.packageJson.push({
+        type: "update",
+        section,
+        name,
+        currentRange: `in ${previousSection}`,
+        nextRange: `move to ${section}`
+      });
+    } else {
+      changes.warnings.push(`${name} already exists in ${currentSection}; expected ${section}. Use --fix-sections to move it.`);
+      return;
+    }
+  }
+  const dependencyMap = ensureObjectField(packageJson, section);
+  const currentRange = dependencyMap[name];
+  if (currentRange === range) {
+    return;
+  }
+  if (typeof currentRange === "string" && !isTargetPackage(name)) {
+    if (isCompatibleRange(currentRange, range) && !options.forceDeps) {
+      return;
+    }
+    if (!options.forceDeps) {
+      changes.warnings.push(`${name} has range ${currentRange}; expected compatible ${range}. Use --force-deps to replace it.`);
+      return;
+    }
+  }
+  dependencyMap[name] = typeof currentRange === "string" ? formatRange(currentRange, range.replace(/^[~^]/u, ""), range === range.replace(/^[~^]/u, "")) : range;
+  const nextRange = String(dependencyMap[name]);
+  changes.packageJson.push({
+    type: typeof currentRange === "string" ? "update" : "install",
+    section,
+    name,
+    currentRange: typeof currentRange === "string" ? currentRange : null,
+    nextRange
+  });
+};
+const resolveLocalBinPath = (cwd, binName) => {
+  const binPath = path.join(cwd, "node_modules", ".bin", process.platform === "win32" ? `${binName}.cmd` : binName);
+  return fs.existsSync(binPath) ? binPath : null;
+};
+const hasLocalPackage = (cwd, packageName) => fs.existsSync(path.join(cwd, "node_modules", packageName, "package.json"));
+const resolveDownloadCommand = (packageName, binName, packageManager, args) => {
+  if (packageManager === "yarn") {
+    const commandArgs2 = ["dlx", "-p", packageName, binName, ...args];
+    return {
+      command: "yarn",
+      args: commandArgs2,
+      display: `yarn ${commandArgs2.join(" ")}`,
+      source: "transient"
+    };
+  }
+  if (packageManager === "pnpm") {
+    const commandArgs2 = ["dlx", "--package", packageName, binName, ...args];
+    return {
+      command: "pnpm",
+      args: commandArgs2,
+      display: `pnpm ${commandArgs2.join(" ")}`,
+      source: "transient"
+    };
+  }
+  if (packageManager === "bun") {
+    const commandArgs2 = ["x", "--package", packageName, binName, ...args];
+    return {
+      command: "bun",
+      args: commandArgs2,
+      display: `bun ${commandArgs2.join(" ")}`,
+      source: "transient"
+    };
+  }
+  const commandArgs = ["exec", "--yes", "--package", packageName, "--", binName, ...args];
+  return {
+    command: "npm",
+    args: commandArgs,
+    display: `npm ${commandArgs.join(" ")}`,
+    source: "transient"
+  };
+};
+const resolvePackageHookCommand = (cwd, packageName, binName, packageManager, args) => {
+  const localBinPath = resolveLocalBinPath(cwd, binName);
+  if (localBinPath) {
+    return {
+      command: localBinPath,
+      args,
+      display: `${localBinPath} ${args.join(" ")}`,
+      source: "local"
+    };
+  }
+  if (hasLocalPackage(cwd, packageName)) {
+    throw new Error(
+      `${packageName} is installed, but ${binName} was not found in node_modules/.bin. Reinstall dependencies or check the package bin metadata.`
+    );
+  }
+  return resolveDownloadCommand(packageName, binName, packageManager, args);
+};
+const getExecErrorMessage = (error) => {
+  if (error instanceof Error && error.message) {
+    return error.message;
+  }
+  return String(error);
+};
+const runPackageHookCommand = (cwd, packageName, binName, packageManager, args, failureMode, options, changes) => {
+  const command = resolvePackageHookCommand(cwd, packageName, binName, packageManager, args);
+  changes.hooks.push(command.display);
+  if (options.dryRun) {
+    return;
+  }
+  try {
+    execFileSync(command.command, command.args, {
+      cwd,
+      stdio: "inherit"
+    });
+  } catch (error) {
+    if (command.source === "transient" && failureMode === "advisory") {
+      changes.warnings.push(`Package hook ${command.display} was skipped: ${getExecErrorMessage(error)}`);
+      return;
+    }
+    throw error;
+  }
+};
+const ROOT_AGENTS_SECTION_HEADER = "## @retailcrm/embed-ui";
+const createRootAgentsSection = () => `${ROOT_AGENTS_SECTION_HEADER}
+
+When working with RetailCRM embedded UI in this project:
+
+1. Use documented public package entrypoints instead of package internals.
+2. Read package README files from \`./node_modules/@retailcrm/embed-ui*\` before changing integration code.
+3. Prefer package-provided \`AGENTS.md\`, MCP resources, YAML profiles, and docs over guessing from source names.
+4. Keep widget targets, page codes, contexts, and host API contracts aligned with package documentation.
+`;
+const appendOrReplaceSection = (content, header, section, force) => {
+  const escapedHeader = header.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  const sectionPattern = new RegExp(`${escapedHeader}[\\s\\S]*?(?=\\n##\\s|$)`, "u");
+  if (sectionPattern.test(content)) {
+    if (!force) {
+      return null;
+    }
+    return content.replace(sectionPattern, section.trimEnd()).replace(/\s+$/u, "") + DEFAULT_NEWLINE;
+  }
+  const trimmed = content.replace(/\s+$/u, "");
+  return `${trimmed}${trimmed ? `${DEFAULT_NEWLINE}${DEFAULT_NEWLINE}` : ""}${section}${DEFAULT_NEWLINE}`;
+};
+const updateRootAgents = (cwd, options, changes) => {
+  const agentsPath = path.join(cwd, "AGENTS.md");
+  const section = createRootAgentsSection();
+  const content = fs.existsSync(agentsPath) ? fs.readFileSync(agentsPath, "utf8") : "# AGENTS.md\n";
+  const nextContent = appendOrReplaceSection(content, ROOT_AGENTS_SECTION_HEADER, section, options.force || options.forceAgents);
+  if (nextContent === null) {
+    changes.skipped.push(`${agentsPath} already contains ${ROOT_AGENTS_SECTION_HEADER}`);
+    return;
+  }
+  if (!options.dryRun) {
+    fs.writeFileSync(agentsPath, nextContent, "utf8");
+  }
+  changes.agents.push(`update ${agentsPath}`);
+};
+const runInitAgentsHook = (packageName, binName, cwd, packageManager, failureMode, options, changes) => {
+  const args = ["init-agents", cwd];
+  if (options.force || options.forceAgents) {
+    args.push("--force");
+  }
+  runPackageHookCommand(
+    cwd,
+    packageName,
+    binName,
+    packageManager,
+    args,
+    failureMode,
+    options,
+    changes
+  );
+};
+const applyInitAgents = (cwd, selectedPackages, packageManager, options, changes) => {
+  if (options.noAgents) {
+    return;
+  }
+  updateRootAgents(cwd, options, changes);
+  for (const selectedPackage of selectedPackages) {
+    for (const hook of selectedPackage.hooks ?? []) {
+      if (hook.type !== "agents") {
+        continue;
+      }
+      if (hook.requiresMcp && options.noMcp) {
+        changes.warnings.push(`Skipping ${selectedPackage.id} ${hook.command} because it currently includes MCP instructions`);
+        continue;
+      }
+      runInitAgentsHook(
+        selectedPackage.name,
+        hook.binName,
+        cwd,
+        packageManager,
+        hook.failureMode,
+        options,
+        changes
+      );
+    }
+  }
+};
+const applyInitPackageConfigHooks = (cwd, selectedPackages, packageManager, options, changes) => {
+  for (const selectedPackage of selectedPackages) {
+    for (const hook of selectedPackage.hooks ?? []) {
+      if (hook.type !== "config") {
+        continue;
+      }
+      if (hook.requiresMcp && options.noMcp) {
+        continue;
+      }
+      const args = [hook.command, cwd];
+      if (hook.requiresMcp && (options.force || options.forceMcp)) {
+        args.push("--force");
+      }
+      if (hook.requiresMcp && options.mcpClientConfigs?.length) {
+        args.push("--mcp-client-configs", options.mcpClientConfigs.join(","));
+      }
+      runPackageHookCommand(
+        cwd,
+        selectedPackage.name,
+        hook.binName,
+        packageManager,
+        args,
+        hook.failureMode,
+        options,
+        changes
+      );
+    }
+  }
+};
+const LOCKFILES = [
+  { file: "yarn.lock", packageManager: "yarn" },
+  { file: "package-lock.json", packageManager: "npm" },
+  { file: "pnpm-lock.yaml", packageManager: "pnpm" },
+  { file: "bun.lockb", packageManager: "bun" }
+];
+const CONFIG_FILES = [
+  "tsconfig.json",
+  "vite.config.ts",
+  "vite.config.js",
+  "vite.config.mts",
+  "eslint.config.js",
+  "eslint.config.mjs",
+  "env.d.ts"
+];
+const SCRIPT_NAMES = ["build", "dev", "eslint", "eslint:fix", "lint", "test"];
+const VITE_CONFIG_FILES = [
+  "vite.config.ts",
+  "vite.config.js",
+  "vite.config.mts"
+];
+const ESLINT_CONFIG_FILES = [
+  "eslint.config.js",
+  "eslint.config.mjs"
+];
+const TEMPLATE_FILE_IMPACTS = [
+  {
+    relativePath: "endpoint/endpoint.worker.ts",
+    impact: "endpoint runner entry will not be generated"
+  },
+  {
+    relativePath: "pages/SettingsPage.vue",
+    impact: "starter settings page will not be generated"
+  },
+  {
+    relativePath: "widgets/OrderCommonAfterWidget.vue",
+    impact: "starter order widget will not be generated"
+  },
+  {
+    relativePath: "i18n/index.ts",
+    impact: "starter i18n bootstrap will not be generated"
+  },
+  {
+    relativePath: "i18n/locales/en-GB.json",
+    impact: "starter English locale messages will not be generated"
+  }
+];
+const hasEnabledMcpConfigHook = (selectedPackages, options) => !options.noMcp && selectedPackages.some(
+  (selectedPackage) => selectedPackage.hooks?.some((hook) => hook.type === "config" && hook.requiresMcp) ?? false
+);
+const readTextIfExists = (filePath) => {
+  if (!fs.existsSync(filePath) || !fs.statSync(filePath).isFile()) {
+    return null;
+  }
+  return fs.readFileSync(filePath, "utf8");
+};
+const hasTextMarker = (content, markers) => markers.some((marker) => content.includes(marker));
+const normalizeRelativePath = (relativePath) => relativePath.split(path.sep).join("/");
+const getSourceRootRelative = (cwd, sourceRoot) => normalizeRelativePath(path.relative(cwd, sourceRoot) || ".");
+const resolveRangeMajor = (range) => {
+  const match = range.match(/\d+/u);
+  return match ? Number(match[0]) : null;
+};
+const describePathState = (cwd, relativePath) => {
+  const targetPath = path.join(cwd, relativePath);
+  if (!fs.existsSync(targetPath)) {
+    return `${relativePath}: missing`;
+  }
+  return `${relativePath}: found`;
+};
+const readExistingPackageJson = (packageJsonPath, changes) => {
+  if (!fs.existsSync(packageJsonPath)) {
+    changes.preflight.push("package.json: missing; it will be created");
+    return null;
+  }
+  const { packageJson } = readPackageJson(packageJsonPath);
+  changes.preflight.push("package.json: found");
+  return packageJson;
+};
+const analyzeDependency = (packageJson, name, expectedRange, expectedSection, options, changes) => {
+  const section = findDependencySection(packageJson, name);
+  if (!section) {
+    return;
+  }
+  const dependencyMap = packageJson[section];
+  const currentRange = typeof dependencyMap === "object" && dependencyMap ? dependencyMap[name] : null;
+  if (section !== expectedSection) {
+    if (options.fixSections) {
+      changes.preflight.push(`${name}: will move from ${section} to ${expectedSection}`);
+    } else {
+      changes.warnings.push(`${name} already exists in ${section}; expected ${expectedSection}. Use --fix-sections to move it.`);
+    }
+  }
+  if (typeof currentRange !== "string") {
+    return;
+  }
+  const currentMajor = resolveRangeMajor(currentRange);
+  const expectedMajor = resolveRangeMajor(expectedRange);
+  if (currentMajor !== null && expectedMajor !== null && currentMajor !== expectedMajor) {
+    if (options.forceDeps) {
+      changes.preflight.push(`${name}: will replace ${currentRange} with ${expectedRange}`);
+    } else {
+      changes.warnings.push(`${name} has range ${currentRange}; expected compatible ${expectedRange}. Use --force-deps to replace it.`);
+    }
+  }
+};
+const analyzePackageJson = (packageJson, selectedPackages, version, options, changes) => {
+  if (packageJson.type === "module") {
+    changes.preflight.push("package.json type: module");
+  } else if (packageJson.type) {
+    changes.warnings.push(`package.json already has type "${String(packageJson.type)}"; expected "module"`);
+  } else {
+    changes.preflight.push('package.json type: missing; "module" will be added');
+  }
+  const scripts = packageJson.scripts;
+  if (scripts && typeof scripts === "object" && !Array.isArray(scripts)) {
+    for (const scriptName of SCRIPT_NAMES) {
+      if (scriptName in scripts) {
+        changes.preflight.push(`script ${scriptName}: found`);
+      }
+    }
+  }
+  const selectedRange = options.exact ? version : `^${version}`;
+  for (const selectedPackage of selectedPackages) {
+    analyzeDependency(packageJson, selectedPackage.name, selectedRange, selectedPackage.section, options, changes);
+  }
+  for (const dependency of INIT_RUNTIME_DEPENDENCIES) {
+    if (dependency.name === I18N_RUNTIME_DEPENDENCY && hasExistingDependency(packageJson, dependency.name)) {
+      changes.preflight.push(`${dependency.name}: found; i18n dependency setup will be skipped to avoid conflicts with existing project configuration`);
+      continue;
+    }
+    analyzeDependency(packageJson, dependency.name, dependency.range, "dependencies", options, changes);
+  }
+  for (const dependency of INIT_DEV_DEPENDENCIES) {
+    analyzeDependency(packageJson, dependency.name, dependency.range, "devDependencies", options, changes);
+  }
+};
+const analyzeTsConfig = (cwd, sourceRoot, changes) => {
+  const tsconfigPath = path.join(cwd, "tsconfig.json");
+  const content = readTextIfExists(tsconfigPath);
+  if (!content) {
+    return;
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(content);
+  } catch {
+    changes.warnings.push("tsconfig.json: cannot parse JSON; verify @ alias, JSON imports, and vue-remote tooling manually");
+    return;
+  }
+  const compilerOptions = parsed.compilerOptions && typeof parsed.compilerOptions === "object" ? parsed.compilerOptions : {};
+  const vueCompilerOptions = parsed.vueCompilerOptions && typeof parsed.vueCompilerOptions === "object" ? parsed.vueCompilerOptions : {};
+  const sourceRootRelative = getSourceRootRelative(cwd, sourceRoot);
+  if (compilerOptions.moduleResolution !== "Bundler") {
+    changes.warnings.push('tsconfig.json: moduleResolution is not "Bundler"; Vite-style imports may resolve differently');
+  }
+  if (compilerOptions.resolveJsonModule !== true) {
+    changes.warnings.push("tsconfig.json: resolveJsonModule is not enabled; JSON locale imports may not type-check");
+  }
+  const paths = compilerOptions.paths && typeof compilerOptions.paths === "object" ? compilerOptions.paths : null;
+  const aliasTarget = paths?.["@/*"];
+  if (!Array.isArray(aliasTarget)) {
+    changes.warnings.push("tsconfig.json: @/* path alias is missing; generated imports use @/");
+  } else if (!aliasTarget.includes(`${sourceRootRelative}/*`)) {
+    changes.warnings.push(`tsconfig.json: @/* path alias does not point to ${sourceRootRelative}/*`);
+  }
+  const plugins = Array.isArray(vueCompilerOptions.plugins) ? vueCompilerOptions.plugins : [];
+  if (!plugins.includes("@omnicajs/vue-remote/tooling")) {
+    changes.warnings.push("tsconfig.json: @omnicajs/vue-remote/tooling plugin is missing; remote script modifiers may not be typed");
+  }
+};
+const analyzeViteConfig = (cwd, sourceRoot, changes) => {
+  const viteConfig = VITE_CONFIG_FILES.map((file) => ({ file, content: readTextIfExists(path.join(cwd, file)) })).find(({ content }) => content !== null);
+  if (!viteConfig?.content) {
+    return;
+  }
+  const sourceRootRelative = getSourceRootRelative(cwd, sourceRoot);
+  if (!hasTextMarker(viteConfig.content, ["@omnicajs/vue-remote/vite-plugin", "vueRemoteVitePlugin"])) {
+    changes.warnings.push(`${viteConfig.file}: @omnicajs/vue-remote/vite-plugin is missing; remote event modifiers will not be transformed`);
+  }
+  if (!hasTextMarker(viteConfig.content, ["@intlify/unplugin-vue-i18n/vite", "vueI18n"])) {
+    changes.warnings.push(`${viteConfig.file}: vue-i18n Vite plugin is missing; JSON and SFC locale blocks may not be bundled`);
+  }
+  if (!hasTextMarker(viteConfig.content, ["vite-svg-loader", "defaultImport: 'component'", 'defaultImport: "component"'])) {
+    changes.warnings.push(`${viteConfig.file}: SVG component loader is missing; generated SVG component imports may fail`);
+  }
+  if (!hasTextMarker(viteConfig.content, ["'@'", '"@"'])) {
+    changes.warnings.push(`${viteConfig.file}: @ alias is missing; generated imports use @/`);
+  } else if (!viteConfig.content.includes(sourceRootRelative) && !viteConfig.content.includes(path.basename(sourceRoot))) {
+    changes.warnings.push(`${viteConfig.file}: @ alias may not point to ${sourceRootRelative}`);
+  }
+};
+const analyzeEslintConfig = (cwd, changes) => {
+  const eslintConfig = ESLINT_CONFIG_FILES.map((file) => ({ file, content: readTextIfExists(path.join(cwd, file)) })).find(({ content }) => content !== null);
+  if (!eslintConfig?.content) {
+    return;
+  }
+  if (!eslintConfig.content.includes("@intlify/eslint-plugin-vue-i18n")) {
+    changes.warnings.push(`${eslintConfig.file}: @intlify/eslint-plugin-vue-i18n is missing; dynamic or missing translation keys will not be guarded`);
+  }
+  if (!eslintConfig.content.includes("@omnicajs/eslint-plugin-dependencies")) {
+    changes.warnings.push(`${eslintConfig.file}: @omnicajs/eslint-plugin-dependencies is missing; generated import ordering may not be enforced`);
+  }
+  if (!eslintConfig.content.includes("vue/block-order")) {
+    changes.warnings.push(`${eslintConfig.file}: vue/block-order is missing; generated Vue block order may drift from the template`);
+  }
+};
+const analyzeTemplateFileSkips = (cwd, sourceRoot, options, changes) => {
+  if (options.noTemplate || options.force || options.forceFiles) {
+    return;
+  }
+  for (const { relativePath, impact } of TEMPLATE_FILE_IMPACTS) {
+    if (fs.existsSync(path.join(sourceRoot, relativePath))) {
+      changes.warnings.push(`${path.join(getSourceRootRelative(cwd, sourceRoot), relativePath)} already exists; ${impact}`);
+    }
+  }
+  for (const relativePath of ["extensionrc.json", "scripts/publish-extension.mjs", "README.md"]) {
+    if (fs.existsSync(path.join(cwd, relativePath))) {
+      changes.warnings.push(`${relativePath} already exists; generated project-level starter file will be skipped`);
+    }
+  }
+};
+const applyInitPreflight = (cwd, sourceRoot, packageManager, selectedPackages, version, options, changes) => {
+  if (options.agentsOnly) {
+    changes.preflight.push("agents-only mode: package.json, configs, and template files are skipped");
+    return;
+  }
+  changes.preflight.push(`source root: ${path.relative(cwd, sourceRoot) || "."}`);
+  const existingLockfiles = LOCKFILES.filter(({ file }) => fs.existsSync(path.join(cwd, file)));
+  if (existingLockfiles.length === 0) {
+    changes.preflight.push(`lockfile: none; using ${packageManager}`);
+  } else {
+    changes.preflight.push(`lockfile: ${existingLockfiles.map(({ file }) => file).join(", ")}; using ${packageManager}`);
+  }
+  if (existingLockfiles.length > 1) {
+    changes.warnings.push(`Multiple lockfiles found: ${existingLockfiles.map(({ file }) => file).join(", ")}`);
+  }
+  if (!options.target && !options.srcDir && fs.existsSync(path.join(cwd, "src")) && path.basename(sourceRoot) === "web") {
+    changes.warnings.push("src/ already exists; generated frontend source root resolved to web/");
+  }
+  changes.preflight.push(describePathState(cwd, "src"));
+  changes.preflight.push(describePathState(cwd, "web"));
+  if (options.noConfigs) {
+    changes.preflight.push("configs: disabled");
+  } else {
+    for (const configFile of CONFIG_FILES) {
+      if (fs.existsSync(path.join(cwd, configFile))) {
+        changes.preflight.push(`${configFile}: found; generated config will be skipped unless --force-files is used`);
+      }
+    }
+    analyzeTsConfig(cwd, sourceRoot, changes);
+    analyzeViteConfig(cwd, sourceRoot, changes);
+    analyzeEslintConfig(cwd, changes);
+  }
+  analyzeTemplateFileSkips(cwd, sourceRoot, options, changes);
+  if (hasEnabledMcpConfigHook(selectedPackages, options)) {
+    changes.preflight.push("v1-endpoint init-config: enabled");
+    if (options.mcpClientConfigs?.length) {
+      changes.preflight.push(`MCP client configs requested: ${options.mcpClientConfigs.join(", ")}`);
+    }
+  }
+  const packageJson = readExistingPackageJson(path.join(cwd, "package.json"), changes);
+  if (packageJson) {
+    analyzePackageJson(packageJson, selectedPackages, version, options, changes);
+  }
+};
+const SKIP_DIRECTORIES = /* @__PURE__ */ new Set([
+  ".git",
+  ".hg",
+  ".svn",
+  ".yarn",
+  "node_modules",
+  "dist",
+  "build",
+  "coverage"
+]);
+const ensureDirectoryExists = (targetPath) => {
+  if (!fs.existsSync(targetPath)) {
+    throw new Error(`Path not found: ${targetPath}`);
+  }
+  const stat = fs.statSync(targetPath);
+  if (!stat.isDirectory()) {
+    throw new Error(`Target is not a directory: ${targetPath}`);
+  }
+};
+const resolvePackageJsonPath = (targetPath) => {
+  if (path.basename(targetPath) === "package.json") {
+    if (!fs.existsSync(targetPath)) {
+      throw new Error(`package.json not found: ${targetPath}`);
+    }
+    return targetPath;
+  }
+  const packageJsonPath = path.resolve(targetPath, "package.json");
+  if (!fs.existsSync(packageJsonPath)) {
+    throw new Error(`package.json not found: ${packageJsonPath}`);
+  }
+  return packageJsonPath;
+};
+const collectPackageJsonPaths = (targetPath) => {
+  const resolvedTarget = path.resolve(targetPath);
+  if (!fs.existsSync(resolvedTarget)) {
+    throw new Error(`Path not found: ${resolvedTarget}`);
+  }
+  if (path.basename(resolvedTarget) === "package.json") {
+    return [resolvedTarget];
+  }
+  ensureDirectoryExists(resolvedTarget);
+  const packageJsonPaths = [];
+  const visit = (directoryPath) => {
+    const packageJsonPath = path.join(directoryPath, "package.json");
+    if (fs.existsSync(packageJsonPath) && fs.statSync(packageJsonPath).isFile()) {
+      packageJsonPaths.push(packageJsonPath);
+    }
+    for (const entry of fs.readdirSync(directoryPath, { withFileTypes: true })) {
+      if (!entry.isDirectory() || entry.isSymbolicLink()) {
+        continue;
+      }
+      if (SKIP_DIRECTORIES.has(entry.name)) {
+        continue;
+      }
+      visit(path.join(directoryPath, entry.name));
+    }
+  };
+  visit(resolvedTarget);
+  return packageJsonPaths.sort();
+};
+const writeFileIfAllowed = (filePath, content, options, changes) => {
+  if (fs.existsSync(filePath) && !options.forceFiles && !options.force) {
+    changes.warnings.push(`${filePath} already exists and will not be overwritten`);
+    return false;
+  }
+  if (!options.dryRun) {
+    fs.mkdirSync(path.dirname(filePath), { recursive: true });
+    fs.writeFileSync(filePath, content, "utf8");
+  }
+  changes.files.push(filePath);
+  return true;
+};
+const ensureDirectory = (directoryPath, options, changes) => {
+  if (fs.existsSync(directoryPath)) {
+    if (!fs.statSync(directoryPath).isDirectory()) {
+      throw new Error(`Target path is not a directory: ${directoryPath}`);
+    }
+    changes.skipped.push(`${directoryPath} already exists`);
+    return;
+  }
+  if (!options.dryRun) {
+    fs.mkdirSync(directoryPath, { recursive: true });
+  }
+  changes.directories.push(directoryPath);
+};
+const endpointWorkerTemplate = "import type { App } from 'vue'\n\nimport { watch } from 'vue'\n\nimport { useField } from '@retailcrm/embed-ui'\n\nimport {\n  definePageRunner,\n  defineRunner,\n  defineWidgetRunner,\n  runEndpoint,\n} from '@retailcrm/embed-ui-v1-endpoint/remote'\nimport {\n  useContext as useSettingsContext,\n} from '@retailcrm/embed-ui-v1-contexts/remote/settings'\n\nimport OrderCommonAfterWidget from '../widgets/OrderCommonAfterWidget.vue'\n\nimport SettingsPage from '../pages/SettingsPage.vue'\n\nimport { i18n } from '../i18n'\n\nconst setupApp = async (app: App) => {\n  app.use(i18n)\n\n  const settings = useSettingsContext()\n  await settings.initialize()\n\n  const locale = useField(settings, 'system.locale')\n\n  i18n.global.locale.value = locale.value\n\n  watch(locale, value => {\n    i18n.global.locale.value = value\n  })\n}\n\nconst runner = defineRunner({\n  pages: [{\n    __PAGE_CODE__: definePageRunner(SettingsPage, setupApp),\n  }],\n  widgets: [{\n    __WIDGET_TARGET__: defineWidgetRunner(OrderCommonAfterWidget, setupApp),\n  }],\n})\n\nrunEndpoint(runner)\n";
+const envDtsTemplate = `/// <reference types="vite/client" />
+
+declare module '*.svg' {
+  import type { DefineComponent } from 'vue'
+
+  const component: DefineComponent<Record<string, never>, Record<string, never>, unknown>
+  export default component
+}
+
+declare module '*.vue' {
+  import type { DefineComponent } from 'vue'
+
+  const component: DefineComponent<Record<string, never>, Record<string, never>, unknown>
+  export default component
+}
+`;
+const eslintConfigTemplate = "import { defineConfig } from 'eslint/config'\n\nimport globals from 'globals'\n\nimport pluginDependencies from '@omnicajs/eslint-plugin-dependencies'\nimport pluginJs from '@eslint/js'\nimport pluginTs from 'typescript-eslint'\nimport pluginVue from 'eslint-plugin-vue'\nimport pluginVueI18n from '@intlify/eslint-plugin-vue-i18n'\n\nexport default defineConfig([\n  { files: ['**/*.{js,mjs,cjs,ts,vue}'] },\n  {\n    settings: {\n      'vue-i18n': {\n        localeDir: {\n          pattern: '__LOCALE_DIR_PATTERN__',\n          localeKey: 'file',\n        },\n        messageSyntaxVersion: '^11.0.0',\n      },\n    },\n  },\n  pluginJs.configs.recommended,\n  ...pluginTs.configs.recommended,\n  ...pluginVue.configs['flat/essential'],\n  ...pluginVueI18n.configs.recommended,\n  {\n    files: ['**/*.{js,mjs,cjs,ts,vue}'],\n    plugins: {\n      '@intlify/vue-i18n': pluginVueI18n,\n      dependencies: pluginDependencies,\n    },\n    languageOptions: {\n      globals: {\n        ...globals.browser,\n        ...globals.node,\n      },\n    },\n    rules: {\n      'comma-dangle': ['error', 'always-multiline'],\n      'eqeqeq': ['error', 'always'],\n      'indent': ['error', 2, { SwitchCase: 1 }],\n      'no-debugger': 'error',\n      'no-multiple-empty-lines': ['error', { max: 1, maxBOF: 0, maxEOF: 0 }],\n      'no-trailing-spaces': 'error',\n      'object-curly-spacing': ['error', 'always'],\n      'quotes': ['error', 'single'],\n      'semi': ['error', 'never'],\n\n      '@typescript-eslint/consistent-type-imports': ['error', {\n        prefer: 'type-imports',\n        fixStyle: 'separate-type-imports',\n      }],\n\n      '@intlify/vue-i18n/key-format-style': ['error', 'camelCase', {\n        allowArray: true,\n      }],\n      '@intlify/vue-i18n/no-duplicate-keys-in-locale': 'error',\n      '@intlify/vue-i18n/no-dynamic-keys': 'error',\n      '@intlify/vue-i18n/no-missing-keys': 'error',\n      '@intlify/vue-i18n/no-missing-keys-in-other-locales': 'error',\n      '@intlify/vue-i18n/no-raw-text': ['warn', {\n        ignorePattern: '^[-–—~+#:()&=×%/\\\\d\\\\s\\\\u00A0\\\\n,.<>•]+$',\n        ignoreText: ['API', 'CRM', ''],\n      }],\n      '@intlify/vue-i18n/no-unknown-locale': 'error',\n      '@intlify/vue-i18n/no-unused-keys': 'error',\n      '@intlify/vue-i18n/sfc-locale-attr': 'error',\n\n      'dependencies/import-style': ['error', {\n        maxSingleLineLength: 90,\n        maxSingleLineSpecifiers: 3,\n      }],\n      'dependencies/separate-type-imports': 'error',\n      'dependencies/separate-type-partitions': 'error',\n      'dependencies/sort-named-imports': ['error', {\n        type: 'alphabetical',\n        ignoreAlias: true,\n      }],\n      'dependencies/sort-imports': ['error', {\n        type: 'alphabetical',\n        imports: {\n          orderBy: 'alias',\n          splitDeclarations: true,\n        },\n        groups: [\n          'side-effect-style',\n          'side-effect',\n          [\n            'type-import',\n            'type-external',\n            'type-vue-components',\n            'type-internal',\n            'type-parent',\n            'type-sibling',\n            'type-index',\n          ],\n          'builtin',\n          'value-external',\n          'value-vue-components',\n          'value-internal',\n          ['value-parent', 'value-sibling'],\n          'index',\n          'ts-equals-import',\n          'unknown',\n        ],\n        customGroups: [{\n          groupName: 'type-vue-components',\n          selector: 'type',\n          elementNamePattern: ['\\\\.(svg|vue)$'],\n        }, {\n          groupName: 'value-vue-components',\n          elementNamePattern: ['\\\\.(svg|vue)$'],\n        }],\n        newlinesInside: 1,\n        partitions: {\n          orderBy: 'type-first',\n          splitBy: {\n            comments: false,\n            newlines: true,\n          },\n        },\n      }],\n    },\n  },\n  {\n    files: ['**/*.vue'],\n    languageOptions: {\n      parserOptions: { parser: pluginTs.parser },\n    },\n    rules: {\n      'vue/block-order': ['error', {\n        order: ['template', 'script', 'i18n', 'style'],\n      }],\n      'vue/attributes-order': 'error',\n      'vue/component-definition-name-casing': ['error', 'PascalCase'],\n      'vue/component-name-in-template-casing': ['error', 'PascalCase'],\n      'vue/html-indent': ['error', 4, {\n        attribute: 1,\n        baseIndent: 1,\n        closeBracket: 0,\n        switchCase: 1,\n      }],\n      'vue/html-self-closing': ['error', {\n        html: {\n          component: 'always',\n          normal: 'always',\n          void: 'always',\n        },\n        math: 'always',\n        svg: 'always',\n      }],\n      'vue/max-attributes-per-line': ['error', {\n        singleline: 4,\n        multiline: { max: 1 },\n      }],\n      'vue/script-indent': ['error', 2, {\n        baseIndent: 0,\n        switchCase: 1,\n      }],\n\n      'indent': 'off',\n    },\n  },\n  { ignores: ['dist/**', 'coverage/**'] },\n])\n";
+const extensionIconTemplate = '<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none">\n  <path d="M12 3 4 7v10l8 4 8-4V7l-8-4Z" stroke="currentColor" stroke-width="1.5" />\n  <path d="m8 10 4 2 4-2M12 12v5" stroke="currentColor" stroke-width="1.5" stroke-linecap="round" />\n</svg>\n';
+const i18nIndexTemplate = "import { createI18n } from 'vue-i18n'\n\nimport enGB from './locales/en-GB.json'\nimport esES from './locales/es-ES.json'\nimport ruRU from './locales/ru-RU.json'\n\nconst messages = {\n  'en-GB': enGB,\n  'es-ES': esES,\n  'ru-RU': ruRU,\n} as const\n\nexport type Locale = keyof typeof messages\nexport type MessageSchema = typeof enGB\n\nexport const i18n = createI18n<[MessageSchema], Locale>({\n  legacy: false,\n  locale: 'ru-RU',\n  fallbackLocale: 'en-GB',\n  messages,\n})\n";
+const orderWidgetTemplate = `<template>
+    <UiToolbarButton @click="openSidebar">
+        {{ t('openSidebar') }}
+    </UiToolbarButton>
+
+    <UiToolbarLink
+        dotted
+        href="javascript:void(0);"
+        @click="openWindow"
+    >
+        {{ t('openWindow') }}
+    </UiToolbarLink>
+
+    <UiModalSidebar v-model:opened="sidebarOpened">
+        <template #title>
+            {{ t('sidebarTitle') }}
+        </template>
+
+        <div :class="$style['order-widget-sidebar']">
+            <p :class="$style['order-widget-sidebar__lead']">{{ t('sidebarLead') }}</p>
+
+            <div :class="$style['order-widget-summary']">
+                <span :class="$style['order-widget-summary__label']">{{ t('sampleTarget') }}</span>
+                <strong :class="$style['order-widget-summary__value']">{{ props.target }}</strong>
+            </div>
+
+            <div :class="$style['order-widget-summary']">
+                <span :class="$style['order-widget-summary__label']">{{ t('sampleCustomer') }}</span>
+                <strong :class="$style['order-widget-summary__value']">{{ t('sampleCustomerValue') }}</strong>
+            </div>
+
+            <UiField
+                :id="fieldIds.followUpNote"
+                v-slot="{ id, ariaInvalid, ariaLabelledby }"
+                :label="t('followUpNote')"
+            >
+                <UiTextbox
+                    :id="id"
+                    v-model:value="followUpNote"
+                    :input-attributes="{
+                        'aria-invalid': ariaInvalid,
+                        'aria-labelledby': ariaLabelledby,
+                    }"
+                    multiline
+                    rows="4"
+                    width="100%"
+                />
+            </UiField>
+
+            <UiField
+                :id="fieldIds.createTask"
+                v-slot="{ id, ariaInvalid, ariaLabelledby }"
+                :label="t('createTask')"
+            >
+                <UiSwitch
+                    :id="id"
+                    v-model:value="createTask"
+                    :aria-invalid="ariaInvalid"
+                    :aria-labelledby="ariaLabelledby"
+                />
+            </UiField>
+        </div>
+
+        <template #footer>
+            <div :class="$style['order-widget-footer']">
+                <UiButton @click="saveDraft">
+                    {{ t('saveDraft') }}
+                </UiButton>
+
+                <UiButton
+                    appearance="secondary"
+                    @click="closeSidebar"
+                >
+                    {{ t('close') }}
+                </UiButton>
+            </div>
+        </template>
+    </UiModalSidebar>
+
+    <UiModalWindow v-model:opened="windowOpened">
+        <template #title>
+            {{ t('windowTitle') }}
+        </template>
+
+        <div :class="$style['order-widget-window']">
+            <p :class="$style['order-widget-window__lead']">{{ t('windowLead') }}</p>
+        </div>
+
+        <template #footer>
+            <div :class="$style['order-widget-footer']">
+                <UiButton @click="saveWindow">
+                    {{ t('save') }}
+                </UiButton>
+
+                <UiButton
+                    appearance="secondary"
+                    @click="windowOpened = false"
+                >
+                    {{ t('cancel') }}
+                </UiButton>
+            </div>
+        </template>
+    </UiModalWindow>
+</template>
+
+<script lang="ts" remote setup>
+import { ref } from 'vue'
+import { useI18n } from 'vue-i18n'
+
+import {
+  UiButton,
+  UiField,
+  UiModalSidebar,
+  UiModalWindow,
+  UiSwitch,
+  UiTextbox,
+  UiToolbarButton,
+  UiToolbarLink,
+} from '@retailcrm/embed-ui-v1-components/remote'
+
+const props = defineProps<{
+  target: string
+}>()
+
+const { t } = useI18n({ useScope: 'local' })
+
+const sidebarOpened = ref(false)
+const windowOpened = ref(false)
+const followUpNote = ref('Call after payment confirmation.')
+const createTask = ref(true)
+
+const fieldIds = {
+  followUpNote: 'order-follow-up-note',
+  createTask: 'order-create-task',
+} as const
+
+const openSidebar = () => {
+  sidebarOpened.value = true
+}
+
+const openWindow = () => {
+  windowOpened.value = true
+}
+
+const closeSidebar = () => {
+  sidebarOpened.value = false
+}
+
+const saveDraft = () => {
+  sidebarOpened.value = false
+}
+
+const saveWindow = () => {
+  windowOpened.value = false
+}
+<\/script>
+
+<i18n locale="en-GB" lang="json">
+{
+  "cancel": "Cancel",
+  "close": "Close",
+  "createTask": "Create task after save",
+  "followUpNote": "Follow-up note",
+  "openSidebar": "Prepare follow-up",
+  "openWindow": "Quick action",
+  "sampleCustomer": "Sample customer",
+  "sampleCustomerValue": "Maria Garcia, paid order",
+  "sampleTarget": "Current target",
+  "save": "Save",
+  "saveDraft": "Save draft",
+  "sidebarLead": "Use this sidebar as a compact place for real order controls.",
+  "sidebarTitle": "Order follow-up",
+  "windowLead": "Use a modal window for a focused confirmation or a short blocking action.",
+  "windowTitle": "Quick order action"
+}
+</i18n>
+
+<i18n locale="es-ES" lang="json">
+{
+  "cancel": "Cancelar",
+  "close": "Cerrar",
+  "createTask": "Crear tarea al guardar",
+  "followUpNote": "Nota de seguimiento",
+  "openSidebar": "Preparar seguimiento",
+  "openWindow": "Accion rapida",
+  "sampleCustomer": "Cliente de ejemplo",
+  "sampleCustomerValue": "Maria Garcia, pedido pagado",
+  "sampleTarget": "Target actual",
+  "save": "Guardar",
+  "saveDraft": "Guardar borrador",
+  "sidebarLead": "Use esta barra lateral como lugar compacto para controles reales del pedido.",
+  "sidebarTitle": "Seguimiento del pedido",
+  "windowLead": "Use una ventana modal para una confirmacion enfocada o una accion bloqueante breve.",
+  "windowTitle": "Accion rapida del pedido"
+}
+</i18n>
+
+<i18n locale="ru-RU" lang="json">
+{
+  "cancel": "Отменить",
+  "close": "Закрыть",
+  "createTask": "Создать задачу после сохранения",
+  "followUpNote": "Заметка для связи",
+  "openSidebar": "Подготовить связь",
+  "openWindow": "Быстрое действие",
+  "sampleCustomer": "Демонстрационный клиент",
+  "sampleCustomerValue": "Мария Гарсия, оплаченный заказ",
+  "sampleTarget": "Текущая цель",
+  "save": "Сохранить",
+  "saveDraft": "Сохранить черновик",
+  "sidebarLead": "Используйте эту боковую панель как компактное место для реальных контролов заказа.",
+  "sidebarTitle": "Связь по заказу",
+  "windowLead": "Используйте модальное окно для точечного подтверждения или короткого блокирующего действия.",
+  "windowTitle": "Быстрое действие с заказом"
+}
+</i18n>
+
+<style lang="less" module>
+@import (reference) '@retailcrm/embed-ui-v1-components/assets/stylesheets/palette.less';
+@import (reference) '@retailcrm/embed-ui-v1-components/assets/stylesheets/typography.less';
+
+.order-widget-sidebar {
+  display: grid;
+  gap: 18px;
+
+  &__lead {
+    .text-small();
+
+    margin: 0;
+    color: @grey-900;
+  }
+}
+
+.order-widget-window {
+  display: grid;
+  gap: 18px;
+
+  &__lead {
+    .text-small();
+
+    margin: 0;
+    color: @grey-900;
+  }
+}
+
+.order-widget-summary {
+  display: grid;
+  gap: 4px;
+  padding: 12px;
+  border: 1px solid @grey-500;
+  border-radius: 6px;
+  background: @grey-100;
+
+  &__label {
+    .text-tiny();
+
+    color: @grey-800;
+  }
+
+  &__value {
+    .text-small-accent();
+
+    color: @black-500;
+  }
+}
+
+.order-widget-footer {
+  display: flex;
+  align-items: center;
+  gap: 12px;
+}
+</style>
+`;
+const publishScriptTemplate = `#!/usr/bin/env node
+
+import { fileURLToPath } from 'node:url'
+
+import fs from 'node:fs'
+
+import path from 'node:path'
+
+import { spawnSync } from 'node:child_process'
+
+const scriptDir = path.dirname(fileURLToPath(import.meta.url))
+const projectRoot = path.resolve(scriptDir, '..')
+const args = new Set(process.argv.slice(2))
+const archiveOnly = args.has('--archive-only')
+
+const readJsonFile = (filePath) => JSON.parse(fs.readFileSync(filePath, 'utf8'))
+
+const loadEnvFile = (filePath) => {
+  if (!fs.existsSync(filePath)) {
+    return
+  }
+
+  for (const line of fs.readFileSync(filePath, 'utf8').split(/\\r?\\n/u)) {
+    const trimmed = line.trim()
+
+    if (!trimmed || trimmed.startsWith('#')) {
+      continue
+    }
+
+    const separatorIndex = trimmed.indexOf('=')
+
+    if (separatorIndex === -1) {
+      continue
+    }
+
+    const key = trimmed.slice(0, separatorIndex).trim()
+    let value = trimmed.slice(separatorIndex + 1).trim()
+
+    if ((value.startsWith('"') && value.endsWith('"')) || (value.startsWith('\\'') && value.endsWith('\\''))) {
+      value = value.slice(1, -1)
+    }
+
+    process.env[key] ??= value
+  }
+}
+
+const assertNonEmptyString = (value, field) => {
+  if (typeof value !== 'string' || value.trim() === '') {
+    throw new Error('Field "' + field + '" must be a non-empty string')
+  }
+
+  return value
+}
+
+const assertStringArray = (value, field) => {
+  if (value === undefined) {
+    return []
+  }
+
+  if (!Array.isArray(value) || value.some(item => typeof item !== 'string' || item.trim() === '')) {
+    throw new Error('Field "' + field + '" must be an array of non-empty strings')
+  }
+
+  return value
+}
+
+const listFiles = (directoryPath, basePath = directoryPath) => {
+  const result = []
+
+  for (const entry of fs.readdirSync(directoryPath, { withFileTypes: true })) {
+    const entryPath = path.join(directoryPath, entry.name)
+    const relativePath = path.relative(basePath, entryPath).split(path.sep).join('/')
+
+    if (entry.isDirectory()) {
+      result.push(...listFiles(entryPath, basePath))
+      continue
+    }
+
+    if (entry.isFile()) {
+      result.push(relativePath)
+    }
+  }
+
+  return result
+}
+
+const normalizeManifestPath = (value) => typeof value === 'string' && value.startsWith('./')
+  ? value.slice(2)
+  : value
+
+const pickBuildArtifacts = (distDir, code) => {
+  const files = listFiles(distDir)
+    .filter(file => file !== 'manifest.json')
+    .filter(file => file !== code + '.zip')
+    .filter(file => !file.endsWith('.map'))
+
+  const viteManifestPath = path.join(distDir, '.vite/manifest.json')
+
+  if (fs.existsSync(viteManifestPath)) {
+    const viteManifest = readJsonFile(viteManifestPath)
+    const entries = Object.values(viteManifest)
+    const entry = entries.find(item => item && item.isEntry) ?? entries[0]
+
+    if (entry?.file) {
+      return {
+        files,
+        scriptFile: normalizeManifestPath(entry.file),
+        styleFile: Array.isArray(entry.css) ? normalizeManifestPath(entry.css[0]) : null,
+      }
+    }
+  }
+
+  return {
+    files,
+    scriptFile: files.find(file => file.endsWith('.js')) ?? null,
+    styleFile: files.find(file => file.endsWith('.css')) ?? null,
+  }
+}
+
+const zipExtension = (distDir, code, extensionManifest, files) => {
+  const archivePath = path.join(distDir, 'extension.zip')
+  const manifestPath = path.join(distDir, 'manifest.json')
+  const previousManifest = fs.existsSync(manifestPath) ? fs.readFileSync(manifestPath) : null
+
+  fs.writeFileSync(manifestPath, JSON.stringify(extensionManifest), 'utf8')
+
+  try {
+    const zipResult = spawnSync('zip', ['-rFS', archivePath, ...files, 'manifest.json'], {
+      cwd: distDir,
+      stdio: 'inherit',
+    })
+
+    if (zipResult.error) {
+      throw new Error('Zip command failed: ' + zipResult.error.message)
+    }
+
+    if (zipResult.status !== 0) {
+      throw new Error('Zip archive creation failed')
+    }
+  } finally {
+    if (previousManifest) {
+      fs.writeFileSync(manifestPath, previousManifest)
+    } else {
+      fs.rmSync(manifestPath, { force: true })
+    }
+  }
+
+  return archivePath
+}
+
+loadEnvFile(path.join(projectRoot, '.env'))
+
+const configPath = path.join(projectRoot, 'extensionrc.json')
+
+if (!fs.existsSync(configPath)) {
+  console.error('Config not found: ' + configPath)
+  process.exit(1)
+}
+
+let config
+
+try {
+  config = readJsonFile(configPath)
+} catch (error) {
+  console.error('Cannot read extensionrc.json:', error)
+  process.exit(1)
+}
+
+try {
+  const code = config.code ?? 'retailcrm-extension-frontend'
+  const uuid = assertNonEmptyString(config.uuid, 'uuid')
+  const version = assertNonEmptyString(config.version, 'version')
+  const targets = assertStringArray(config.targets, 'targets')
+  const pages = assertStringArray(config.pages, 'pages')
+  const runner = config.runner ?? 'worker'
+
+  if (targets.length === 0 && pages.length === 0) {
+    throw new Error('Specify at least one target or page in extensionrc.json')
+  }
+
+  const distDir = path.join(projectRoot, 'dist')
+
+  if (!fs.existsSync(distDir)) {
+    throw new Error('Build directory not found: ' + distDir)
+  }
+
+  const { files, scriptFile, styleFile } = pickBuildArtifacts(distDir, code)
+
+  if (!scriptFile) {
+    throw new Error('Missing JS build artifact. Run npm run build before publishing.')
+  }
+
+  const extensionManifest = {
+    code,
+    version,
+    entrypoint: scriptFile,
+    scripts: [scriptFile],
+    runner,
+  }
+
+  if (targets.length > 0) {
+    extensionManifest.targets = targets
+  }
+
+  if (pages.length > 0) {
+    extensionManifest.pages = pages
+  }
+
+  if (styleFile) {
+    extensionManifest.stylesheet = styleFile
+  }
+
+  const archivePath = zipExtension(distDir, code, extensionManifest, files)
+
+  console.log('Archive created: ' + archivePath)
+
+  if (archiveOnly) {
+    process.exit(0)
+  }
+
+  const crmHost = process.env.CRM_API_HOST
+  const crmKey = process.env.CRM_API_KEY
+  const baseUrl = config.baseUrl || process.env.MODULE_URL || process.env.EXTENSION_BASE_URL
+
+  if (!crmHost || !crmKey) {
+    throw new Error('Missing CRM_API_HOST or CRM_API_KEY in .env')
+  }
+
+  if (!baseUrl) {
+    throw new Error('Missing MODULE_URL or EXTENSION_BASE_URL in .env or baseUrl in extensionrc.json')
+  }
+
+  const embedJs = {
+    entrypoint: config.entrypoint || '/extension/' + uuid + '/script',
+    runner,
+  }
+
+  if (targets.length > 0) {
+    embedJs.targets = targets
+  }
+
+  if (pages.length > 0) {
+    embedJs.pages = pages
+  }
+
+  if (styleFile && config.stylesheet !== false) {
+    embedJs.stylesheet = typeof config.stylesheet === 'string'
+      ? config.stylesheet
+      : '/extension/' + uuid + '/stylesheet'
+  }
+
+  const integrationModule = {
+    code,
+    integrationCode: code,
+    active: true,
+    name: config.name || code,
+    clientId: config.clientId || 'client-id-xxx',
+    baseUrl,
+    integrations: {
+      embedJs,
+    },
+  }
+
+  const form = new FormData()
+  form.append('integrationModule', JSON.stringify(integrationModule))
+
+  const response = await fetch(new URL('/api/v5/integration-modules/' + code + '/edit', crmHost), {
+    method: 'POST',
+    headers: {
+      'X-Api-Key': crmKey,
+    },
+    body: form,
+  })
+
+  const text = await response.text()
+
+  if (!response.ok) {
+    console.error('Request failed: ' + response.status + ' ' + response.statusText)
+    console.error(text)
+    process.exit(1)
+  }
+
+  console.log(text)
+} catch (error) {
+  console.error(error instanceof Error ? error.message : error)
+  process.exit(1)
+}
+`;
+const readmeEnGBTemplate = "# RetailCRM extension frontend\n\nThis project was generated by `embed-ui init`.\n\n## What Was Added\n\n- `package.json` with scripts for Vite build, ESLint, and extension publishing.\n- `extensionrc.json` with the generated extension manifest source.\n- `__SOURCE_ROOT__/endpoint/endpoint.worker.ts` with `defineRunner`, one page runner, and one widget runner.\n- `__SOURCE_ROOT__/pages/SettingsPage.vue` as a starter settings page.\n- `__SOURCE_ROOT__/widgets/OrderCommonAfterWidget.vue` as a starter order widget.\n- `__SOURCE_ROOT__/i18n/` with shared JSON message files.\n- `scripts/publish-extension.mjs` for creating `dist/extension.zip` and publishing the integration module through RetailCRM API.\n- `AGENTS.md` when agent instructions were enabled during init.\n\n## Replace Generic Values\n\nReview these generated placeholders before using the project in a real integration:\n\n- Extension code in `extensionrc.json`: `retailcrm-extension-frontend`.\n- Extension name in `extensionrc.json`: `RetailCRM Extension Frontend`.\n- Page code: `__PAGE_CODE__`.\n- Widget target: `__WIDGET_TARGET__`.\n- Sample controls and fake data in `__SOURCE_ROOT__/pages/SettingsPage.vue`.\n- Sample toolbar actions and fake order data in `__SOURCE_ROOT__/widgets/OrderCommonAfterWidget.vue`.\n- Shared messages in `__SOURCE_ROOT__/i18n/locales/*.json`.\n\nThe generated page and widget are intentionally generic. Keep the structure you need, but replace the sample labels, fields, and fake data with real product behavior.\n\n## Vue File Names\n\n`SettingsPage.vue` and `OrderCommonAfterWidget.vue` are generic starter names. In product code, rename Vue files after the role they play in the extension, and update imports in `__SOURCE_ROOT__/endpoint/endpoint.worker.ts`.\n\nExamples from RetailCRM extension examples:\n\n- `ReturnsPage.vue` is a full returns-management page.\n- `TasksPage.vue` is a task list/workspace page.\n- `SummaryPage.vue` is a summary dashboard page.\n- `RecordToCalendlyWidget.vue` is a focused widget for one scenario.\n\nUse the same idea for your code: `LoyaltySettingsPage.vue`, `OrderNotesWidget.vue`, `PaymentStatusSidebar.vue`, or another name that describes the real scenario.\n\n## Commands\n\n```bash\n__PACKAGE_MANAGER__ install\n__PACKAGE_MANAGER_RUN__ eslint\n__PACKAGE_MANAGER_RUN__ build\n__PACKAGE_MANAGER_RUN__ publish-extension -- --archive-only\n```\n\n## Publishing\n\nCreate `.env` in the project root when you want `publish-extension` to update RetailCRM:\n\n```dotenv\nCRM_API_HOST=https://example.retailcrm.pro\nCRM_API_KEY=your-api-key\nMODULE_URL=https://example.com\n```\n\nRun `__PACKAGE_MANAGER_RUN__ build` before publishing. The archive-only mode creates `dist/extension.zip` without sending API requests.\n";
+const readmeEsESTemplate = "# Frontend de extension RetailCRM\n\nEste proyecto fue generado por `embed-ui init`.\n\n## Que Se Agrego\n\n- `package.json` con scripts para Vite build, ESLint y publicacion de la extension.\n- `extensionrc.json` con la fuente del manifiesto de la extension.\n- `__SOURCE_ROOT__/endpoint/endpoint.worker.ts` con `defineRunner`, un runner de pagina y un runner de widget.\n- `__SOURCE_ROOT__/pages/SettingsPage.vue` como pagina inicial de configuracion.\n- `__SOURCE_ROOT__/widgets/OrderCommonAfterWidget.vue` como widget inicial del pedido.\n- `__SOURCE_ROOT__/i18n/` con archivos JSON de mensajes compartidos.\n- `scripts/publish-extension.mjs` para crear `dist/extension.zip` y publicar el modulo de integracion por RetailCRM API.\n- `AGENTS.md` si las instrucciones para agentes estaban activadas durante init.\n\n## Sustituya Los Valores Genericos\n\nRevise estos valores generados antes de usar el proyecto en una integracion real:\n\n- Codigo de extension en `extensionrc.json`: `retailcrm-extension-frontend`.\n- Nombre de extension en `extensionrc.json`: `RetailCRM Extension Frontend`.\n- Codigo de pagina: `__PAGE_CODE__`.\n- Target del widget: `__WIDGET_TARGET__`.\n- Controles de ejemplo y datos ficticios en `__SOURCE_ROOT__/pages/SettingsPage.vue`.\n- Acciones toolbar de ejemplo y datos ficticios del pedido en `__SOURCE_ROOT__/widgets/OrderCommonAfterWidget.vue`.\n- Mensajes compartidos en `__SOURCE_ROOT__/i18n/locales/*.json`.\n\nLa pagina y el widget generados son intencionalmente genericos. Mantenga la estructura que necesite, pero sustituya etiquetas, campos y datos ficticios por comportamiento real del producto.\n\n## Nombres De Archivos Vue\n\n`SettingsPage.vue` y `OrderCommonAfterWidget.vue` son nombres iniciales genericos. En codigo de producto, renombre los archivos Vue segun la funcion que cumplen en la extension y actualice los imports en `__SOURCE_ROOT__/endpoint/endpoint.worker.ts`.\n\nEjemplos del repositorio de extensiones RetailCRM:\n\n- `ReturnsPage.vue` es una pagina completa de gestion de devoluciones.\n- `TasksPage.vue` es una pagina de lista o espacio de trabajo de tareas.\n- `SummaryPage.vue` es una pagina de resumen o dashboard.\n- `RecordToCalendlyWidget.vue` es un widget enfocado en un escenario.\n\nUse la misma idea para su codigo: `LoyaltySettingsPage.vue`, `OrderNotesWidget.vue`, `PaymentStatusSidebar.vue` u otro nombre que describa el escenario real.\n\n## Comandos\n\n```bash\n__PACKAGE_MANAGER__ install\n__PACKAGE_MANAGER_RUN__ eslint\n__PACKAGE_MANAGER_RUN__ build\n__PACKAGE_MANAGER_RUN__ publish-extension -- --archive-only\n```\n\n## Publicacion\n\nCree `.env` en la raiz del proyecto cuando quiera que `publish-extension` actualice RetailCRM:\n\n```dotenv\nCRM_API_HOST=https://example.retailcrm.pro\nCRM_API_KEY=your-api-key\nMODULE_URL=https://example.com\n```\n\nEjecute `__PACKAGE_MANAGER_RUN__ build` antes de publicar. El modo archive-only crea `dist/extension.zip` sin enviar peticiones API.\n";
+const readmeRuRUTemplate = "# Фронтенд расширения RetailCRM\n\nПроект создан командой `embed-ui init`.\n\n## Что Добавлено\n\n- `package.json` со скриптами для сборки Vite, ESLint и публикации расширения.\n- `extensionrc.json` с исходным описанием манифеста расширения.\n- `__SOURCE_ROOT__/endpoint/endpoint.worker.ts` с `defineRunner`, одним runner страницы и одним runner виджета.\n- `__SOURCE_ROOT__/pages/SettingsPage.vue` как стартовая страница настроек.\n- `__SOURCE_ROOT__/widgets/OrderCommonAfterWidget.vue` как стартовый виджет заказа.\n- `__SOURCE_ROOT__/i18n/` с общими JSON-файлами переводов.\n- `scripts/publish-extension.mjs` для создания `dist/extension.zip` и публикации интеграционного модуля через RetailCRM API.\n- `AGENTS.md`, если при инициализации были включены инструкции для агентов.\n\n## Замените Generic Значения\n\nПеред использованием проекта в реальной интеграции проверьте сгенерированные общие значения:\n\n- Код расширения в `extensionrc.json`: `retailcrm-extension-frontend`.\n- Название расширения в `extensionrc.json`: `RetailCRM Extension Frontend`.\n- Код страницы: `__PAGE_CODE__`.\n- Цель виджета: `__WIDGET_TARGET__`.\n- Демонстрационные контролы и ненастоящие данные в `__SOURCE_ROOT__/pages/SettingsPage.vue`.\n- Демонстрационные toolbar-действия и ненастоящие данные заказа в `__SOURCE_ROOT__/widgets/OrderCommonAfterWidget.vue`.\n- Общие сообщения в `__SOURCE_ROOT__/i18n/locales/*.json`.\n\nСгенерированные страница и виджет намеренно сделаны универсальными. Оставьте нужную структуру, но замените примерные подписи, поля и ненастоящие данные на реальное поведение продукта.\n\n## Имена Vue-Файлов\n\n`SettingsPage.vue` и `OrderCommonAfterWidget.vue` — универсальные стартовые имена. В продуктовом коде переименуйте Vue-файлы по роли, которую они выполняют в расширении, и обновите импорты в `__SOURCE_ROOT__/endpoint/endpoint.worker.ts`.\n\nПримеры из репозитория расширений RetailCRM:\n\n- `ReturnsPage.vue` — полноценная страница управления возвратами.\n- `TasksPage.vue` — страница списка задач или рабочей области задач.\n- `SummaryPage.vue` — страница сводки или дашборда.\n- `RecordToCalendlyWidget.vue` — сфокусированный виджет под один сценарий.\n\nИспользуйте тот же принцип: `LoyaltySettingsPage.vue`, `OrderNotesWidget.vue`, `PaymentStatusSidebar.vue` или другое имя, которое описывает реальный сценарий.\n\n## Команды\n\n```bash\n__PACKAGE_MANAGER__ install\n__PACKAGE_MANAGER_RUN__ eslint\n__PACKAGE_MANAGER_RUN__ build\n__PACKAGE_MANAGER_RUN__ publish-extension -- --archive-only\n```\n\n## Публикация\n\nСоздайте `.env` в корне проекта, когда потребуется обновлять RetailCRM через `publish-extension`:\n\n```dotenv\nCRM_API_HOST=https://example.retailcrm.pro\nCRM_API_KEY=your-api-key\nMODULE_URL=https://example.com\n```\n\nПеред публикацией выполните `__PACKAGE_MANAGER_RUN__ build`. Режим archive-only создает `dist/extension.zip` без API-запросов.\n";
+const settingsPageTemplate = `<template>
+    <main :class="$style['settings-page']">
+        <UiPageHeader :value="t('title')">
+            <template #addon>
+                <div :class="$style['settings-page-addon']">
+                    <ExtensionIcon
+                        :class="$style['settings-page-addon__icon']"
+                        aria-hidden="true"
+                    />
+                    <span :class="$style['settings-page-addon__subtitle']">{{ t('subtitle') }}</span>
+                </div>
+            </template>
+
+            <template #actions>
+                <UiButton @click="saveSettings">
+                    {{ t('save') }}
+                </UiButton>
+            </template>
+        </UiPageHeader>
+
+        <section :class="$style['settings-form']">
+            <div :class="$style['settings-form__intro']">
+                <h2 :class="$style['settings-form__heading']">{{ t('workspaceTitle') }}</h2>
+                <p :class="$style['settings-form__description']">{{ t('workspaceDescription') }}</p>
+            </div>
+
+            <div :class="$style['settings-form__grid']">
+                <UiField
+                    :id="fieldIds.assistantName"
+                    v-slot="{ id, ariaInvalid, ariaLabelledby }"
+                    :hint="t('assistantNameHint')"
+                    :hint-aria-label="t('hint')"
+                    :label="t('assistantName')"
+                >
+                    <UiTextbox
+                        :id="id"
+                        v-model:value="assistantName"
+                        :input-attributes="{
+                            'aria-invalid': ariaInvalid,
+                            'aria-labelledby': ariaLabelledby,
+                        }"
+                        width="100%"
+                        @update:value="resetSaved"
+                    />
+                </UiField>
+
+                <UiField
+                    :id="fieldIds.owner"
+                    v-slot="{ id, ariaInvalid, ariaLabelledby }"
+                    :label="t('owner')"
+                >
+                    <UiSelect
+                        :id="id"
+                        v-model:value="owner"
+                        :aria-invalid="ariaInvalid"
+                        :aria-labelledby="ariaLabelledby"
+                        width="100%"
+                        @update:value="resetSaved"
+                    >
+                        <UiSelectOption
+                            value="sales"
+                            :label="t('ownerSales')"
+                        />
+                        <UiSelectOption
+                            value="delivery"
+                            :label="t('ownerDelivery')"
+                        />
+                    </UiSelect>
+                </UiField>
+
+                <UiField
+                    :id="fieldIds.note"
+                    v-slot="{ id, ariaInvalid, ariaLabelledby }"
+                    :class="$style['settings-form__note']"
+                    :label="t('note')"
+                >
+                    <UiTextbox
+                        :id="id"
+                        v-model:value="note"
+                        :input-attributes="{
+                            'aria-invalid': ariaInvalid,
+                            'aria-labelledby': ariaLabelledby,
+                        }"
+                        multiline
+                        rows="4"
+                        width="100%"
+                        @update:value="resetSaved"
+                    />
+                </UiField>
+
+                <UiField
+                    :id="fieldIds.enabled"
+                    v-slot="{ id, ariaInvalid, ariaLabelledby }"
+                    :label="t('enabled')"
+                >
+                    <UiSwitch
+                        :id="id"
+                        v-model:value="enabled"
+                        :aria-invalid="ariaInvalid"
+                        :aria-labelledby="ariaLabelledby"
+                        @update:value="resetSaved"
+                    />
+                </UiField>
+            </div>
+
+            <p
+                v-if="saved"
+                :class="$style['settings-form__status']"
+            >
+                {{ t('saved') }}
+            </p>
+        </section>
+    </main>
+</template>
+
+<script lang="ts" remote setup>
+import { ref } from 'vue'
+import { useI18n } from 'vue-i18n'
+
+import {
+  UiButton,
+  UiField,
+  UiPageHeader,
+  UiSelect,
+  UiSelectOption,
+  UiSwitch,
+  UiTextbox,
+} from '@retailcrm/embed-ui-v1-components/remote'
+
+import ExtensionIcon from '@/shared/assets/extension.svg'
+
+const { t } = useI18n({ useScope: 'local' })
+
+const assistantName = ref('Order follow-up')
+const owner = ref('sales')
+const enabled = ref(true)
+const note = ref('Check payment status and delivery date before calling the customer.')
+const saved = ref(false)
+
+const fieldIds = {
+  assistantName: 'extension-assistant-name',
+  note: 'extension-note',
+  owner: 'extension-owner',
+  enabled: 'extension-enabled',
+} as const
+
+const resetSaved = () => {
+  saved.value = false
+}
+
+const saveSettings = () => {
+  saved.value = true
+}
+<\/script>
+
+<i18n locale="en-GB" lang="json">
+{
+  "assistantName": "Assistant name",
+  "assistantNameHint": "Use this value as a starter label for your real setting.",
+  "enabled": "Enable order prompts",
+  "hint": "Hint",
+  "note": "Default note",
+  "owner": "Responsible team",
+  "ownerDelivery": "Delivery team",
+  "ownerSales": "Sales team",
+  "save": "Save",
+  "saved": "Settings saved",
+  "subtitle": "Starter configuration page",
+  "title": "Extension settings",
+  "workspaceDescription": "Replace these sample controls with settings that drive your embedded page and order widget.",
+  "workspaceTitle": "Order workflow defaults"
+}
+</i18n>
+
+<i18n locale="es-ES" lang="json">
+{
+  "assistantName": "Nombre del asistente",
+  "assistantNameHint": "Use este valor como etiqueta inicial para su ajuste real.",
+  "enabled": "Activar sugerencias del pedido",
+  "hint": "Ayuda",
+  "note": "Nota predeterminada",
+  "owner": "Equipo responsable",
+  "ownerDelivery": "Equipo de entrega",
+  "ownerSales": "Equipo comercial",
+  "save": "Guardar",
+  "saved": "Configuracion guardada",
+  "subtitle": "Pagina inicial de configuracion",
+  "title": "Configuracion de la extension",
+  "workspaceDescription": "Sustituya estos controles de ejemplo por ajustes que controlen su pagina integrada y el widget del pedido.",
+  "workspaceTitle": "Valores iniciales del proceso de pedidos"
+}
+</i18n>
+
+<i18n locale="ru-RU" lang="json">
+{
+  "assistantName": "Название помощника",
+  "assistantNameHint": "Используйте это значение как стартовую подпись для реальной настройки.",
+  "enabled": "Включить подсказки в заказе",
+  "hint": "Подсказка",
+  "note": "Заметка по умолчанию",
+  "owner": "Ответственная команда",
+  "ownerDelivery": "Команда доставки",
+  "ownerSales": "Отдел продаж",
+  "save": "Сохранить",
+  "saved": "Настройки сохранены",
+  "subtitle": "Стартовая страница настроек",
+  "title": "Настройки расширения",
+  "workspaceDescription": "Замените эти демонстрационные контролы настройками, которые управляют встроенной страницей и виджетом заказа.",
+  "workspaceTitle": "Настройки сценария заказа"
+}
+</i18n>
+
+<style lang="less" module>
+@import (reference) '@retailcrm/embed-ui-v1-components/assets/stylesheets/geometry.less';
+@import (reference) '@retailcrm/embed-ui-v1-components/assets/stylesheets/layout.less';
+@import (reference) '@retailcrm/embed-ui-v1-components/assets/stylesheets/palette.less';
+@import (reference) '@retailcrm/embed-ui-v1-components/assets/stylesheets/typography.less';
+
+.settings-page {
+  display: grid;
+  gap: @spacing-md;
+  max-width: 960px;
+
+  @media (max-width: 720px) {
+    gap: @spacing-sm;
+  }
+}
+
+.settings-page-addon {
+  display: flex;
+  align-items: center;
+  gap: @spacing-xs;
+  min-width: 0;
+
+  &__icon {
+    .square(@line-height-regular);
+
+    flex: none;
+    color: @blue-600;
+  }
+
+  &__subtitle {
+    .ellipsis();
+    .text-tiny(18px);
+
+    color: @grey-900;
+  }
+}
+
+.settings-form {
+  display: grid;
+  gap: @spacing-sm + @spacing-xxs;
+  padding: @spacing-md;
+  border: 1px solid @grey-500;
+  border-radius: @border-radius-lg;
+  background: white;
+
+  @media (max-width: 720px) {
+    padding: @spacing-sm;
+  }
+
+  &__intro {
+    display: grid;
+    gap: @spacing-xxs + 2px;
+  }
+
+  &__heading {
+    .h4-accent(24px);
+
+    margin: 0;
+    color: @black-500;
+  }
+
+  &__description {
+    .text-small();
+
+    max-width: 640px;
+    margin: 0;
+    color: @grey-900;
+  }
+
+  &__grid {
+    display: grid;
+    grid-template-columns: repeat(2, minmax(240px, 1fr));
+    gap: (@spacing-sm + 2px) @spacing-md;
+
+    @media (max-width: 720px) {
+      grid-template-columns: 1fr;
+    }
+  }
+
+  &__note {
+    grid-column: 1 / -1;
+  }
+
+  &__status {
+    .text-tiny(18px);
+
+    margin: 0;
+    color: @green-800;
+  }
+}
+</style>
+`;
+const tsConfigTemplate = '{\n  "compilerOptions": {\n    "target": "ES2022",\n    "useDefineForClassFields": true,\n    "module": "ESNext",\n    "moduleResolution": "Bundler",\n    "strict": true,\n    "jsx": "preserve",\n    "resolveJsonModule": true,\n    "isolatedModules": true,\n    "skipLibCheck": true,\n    "allowSyntheticDefaultImports": true,\n    "esModuleInterop": true,\n    "baseUrl": ".",\n    "paths": {\n      "@/*": [\n        "__SOURCE_ROOT_RELATIVE__/*"\n      ]\n    }\n  },\n  "include": [\n    "__SOURCE_ROOT_RELATIVE__/**/*",\n    "env.d.ts"\n  ],\n  "vueCompilerOptions": {\n    "plugins": [\n      "@omnicajs/vue-remote/tooling"\n    ]\n  }\n}\n';
+const viteConfigTemplate = "import { fileURLToPath } from 'node:url'\n\nimport path from 'node:path'\n\nimport { defineConfig } from 'vite'\n\nimport vue from '@vitejs/plugin-vue'\nimport vueRemoteVitePlugin from '@omnicajs/vue-remote/vite-plugin'\n\nimport vueI18n from '@intlify/unplugin-vue-i18n/vite'\n\nimport svgLoader from 'vite-svg-loader'\n\nconst root = path.dirname(fileURLToPath(import.meta.url))\n\nexport default defineConfig({\n  plugins: [\n    svgLoader({\n      defaultImport: 'component',\n    }),\n    vueRemoteVitePlugin(),\n    vue(),\n    vueI18n({\n      defaultSFCLang: 'json',\n      include: path.resolve(root, '__LOCALE_INCLUDE_PATTERN__/**/*.{json,json5,yaml,yml}'),\n    }),\n  ],\n  resolve: {\n    alias: {\n      '@': path.resolve(root, __SOURCE_ROOT_PATH__),\n    },\n  },\n  build: {\n    rollupOptions: {\n      input: path.resolve(root, __ENTRY_PATH__),\n    },\n  },\n})\n";
+const toPosixRelative = (from, to) => {
+  const relativePath = path.relative(from, to) || ".";
+  return relativePath.split(path.sep).join("/");
+};
+const quoteJsString = (value) => `'${value.replace(/\\/gu, "\\\\").replace(/'/gu, "\\'")}'`;
+const replaceTemplateVars = (template, vars) => {
+  let content = template;
+  for (const [key, value] of Object.entries(vars)) {
+    content = content.replaceAll(`__${key}__`, value);
+  }
+  return content;
+};
+const readmeTemplates = {
+  "en-GB": readmeEnGBTemplate,
+  "es-ES": readmeEsESTemplate,
+  "ru-RU": readmeRuRUTemplate
+};
+const normalizeLocale = (value) => {
+  const normalized = value?.split(".")[0].replace("_", "-").toLowerCase();
+  if (!normalized) {
+    return null;
+  }
+  if (normalized.startsWith("ru")) {
+    return "ru-RU";
+  }
+  if (normalized.startsWith("es")) {
+    return "es-ES";
+  }
+  if (normalized.startsWith("en")) {
+    return "en-GB";
+  }
+  return null;
+};
+const detectReadmeLocale = () => {
+  const envCandidates = [
+    process.env.LANGUAGE?.split(":")[0],
+    process.env.LC_ALL,
+    process.env.LC_MESSAGES,
+    process.env.LANG
+  ];
+  for (const candidate of envCandidates) {
+    const locale = normalizeLocale(candidate);
+    if (locale) {
+      return locale;
+    }
+  }
+  return "en-GB";
+};
+const createPackageManagerRunCommand = (packageManager) => {
+  if (packageManager === "npm") {
+    return "npm run";
+  }
+  if (packageManager === "bun") {
+    return "bun run";
+  }
+  return packageManager;
+};
+const createEnvDts = () => envDtsTemplate;
+const createTsConfig = (cwd, sourceRoot) => replaceTemplateVars(
+  tsConfigTemplate,
+  {
+    SOURCE_ROOT_RELATIVE: toPosixRelative(cwd, sourceRoot)
+  }
+);
+const createViteConfig = (cwd, sourceRoot) => replaceTemplateVars(
+  viteConfigTemplate,
+  {
+    ENTRY_PATH: quoteJsString(toPosixRelative(cwd, path.join(sourceRoot, "endpoint/endpoint.worker.ts"))),
+    LOCALE_INCLUDE_PATTERN: toPosixRelative(cwd, path.join(sourceRoot, "i18n/locales")),
+    SOURCE_ROOT_PATH: quoteJsString(toPosixRelative(cwd, sourceRoot))
+  }
+);
+const createEslintConfig = (cwd, sourceRoot) => replaceTemplateVars(
+  eslintConfigTemplate,
+  {
+    LOCALE_DIR_PATTERN: `./${toPosixRelative(cwd, path.join(sourceRoot, "i18n/locales"))}/*.{json,json5,yaml,yml}`
+  }
+);
+const createEndpointWorker = (options) => replaceTemplateVars(
+  endpointWorkerTemplate,
+  {
+    PAGE_CODE: quoteJsString(options.pageCode),
+    WIDGET_TARGET: quoteJsString(options.widgetTarget)
+  }
+);
+const createI18nIndex = () => i18nIndexTemplate;
+const createSettingsPage = () => settingsPageTemplate;
+const createOrderWidget = () => orderWidgetTemplate;
+const createMessages = () => `${JSON.stringify({}, null, 2)}${DEFAULT_NEWLINE}`;
+const createExtensionConfig = (options) => `${JSON.stringify({
+  code: "retailcrm-extension-frontend",
+  name: "RetailCRM Extension Frontend",
+  uuid: randomUUID(),
+  version: "1.0.0",
+  targets: [options.widgetTarget],
+  pages: [options.pageCode],
+  stylesheet: true,
+  entrypointType: "script",
+  runner: "worker"
+}, null, 2)}${DEFAULT_NEWLINE}`;
+const createExtensionIcon = () => extensionIconTemplate;
+const createPublishScript = () => publishScriptTemplate;
+const createReadme = (cwd, sourceRoot, options, packageManager) => replaceTemplateVars(
+  readmeTemplates[detectReadmeLocale()],
+  {
+    PACKAGE_MANAGER: packageManager,
+    PACKAGE_MANAGER_RUN: createPackageManagerRunCommand(packageManager),
+    PAGE_CODE: options.pageCode,
+    SOURCE_ROOT: toPosixRelative(cwd, sourceRoot),
+    WIDGET_TARGET: options.widgetTarget
+  }
+);
+const createInitChanges = () => ({
+  preflight: [],
+  packageJson: [],
+  directories: [],
+  files: [],
+  agents: [],
+  mcp: [],
+  hooks: [],
+  install: null,
+  skipped: [],
+  warnings: []
+});
+const printChanges = (changes) => {
+  for (const change of changes) {
+    let prefix;
+    if (change.type === "script") {
+      prefix = `scripts: ${change.name} -> ${change.nextRange}`;
+    } else if (change.type === "field") {
+      prefix = `${change.name} -> ${change.nextRange}`;
+    } else {
+      prefix = change.type === "install" ? `${change.section}: ${change.name} -> ${change.nextRange}` : `${change.section}: ${change.name} ${change.currentRange} -> ${change.nextRange}`;
+    }
+    console.log(`  ${prefix}`);
+  }
+};
+const printInitReport = (cwd, sourceRoot, version, packageManager, changes, options) => {
+  console.log(`CWD: ${cwd}`);
+  console.log(`Target: ${sourceRoot}`);
+  console.log(`Resolved version: ${version}`);
+  console.log(`Package manager: ${packageManager}`);
+  if (changes.preflight.length > 0) {
+    console.log("");
+    console.log("preflight");
+    for (const item of changes.preflight) {
+      console.log(`  ${item}`);
+    }
+  }
+  if (changes.packageJson.length > 0) {
+    console.log("");
+    console.log("package.json");
+    printChanges(changes.packageJson);
+  }
+  if (changes.directories.length > 0) {
+    console.log("");
+    console.log("directories");
+    for (const directoryPath of changes.directories) {
+      console.log(`  create ${directoryPath}`);
+    }
+  }
+  if (changes.files.length > 0) {
+    console.log("");
+    console.log("files");
+    for (const filePath of changes.files) {
+      console.log(`  create ${filePath}`);
+    }
+  }
+  if (changes.agents.length > 0) {
+    console.log("");
+    console.log("AGENTS.md");
+    for (const agentChange of changes.agents) {
+      console.log(`  ${agentChange}`);
+    }
+  }
+  if (changes.mcp.length > 0) {
+    console.log("");
+    console.log("MCP");
+    for (const mcpChange of changes.mcp) {
+      console.log(`  ${mcpChange}`);
+    }
+  }
+  if (changes.hooks.length > 0) {
+    console.log("");
+    console.log("package hooks");
+    for (const hook of changes.hooks) {
+      console.log(`  ${options.dryRun ? "would run" : "ran"} ${hook}`);
+    }
+  }
+  if (changes.install) {
+    console.log("");
+    console.log("install");
+    console.log(`  ${changes.install}`);
+  }
+  if (changes.skipped.length > 0) {
+    console.log("");
+    console.log("skipped");
+    for (const skipped of changes.skipped) {
+      console.log(`  ${skipped}`);
+    }
+  }
+  if (changes.warnings.length > 0) {
+    console.log("");
+    console.log("warnings");
+    for (const warning of new Set(changes.warnings)) {
+      console.log(`  ${warning}`);
+    }
+  }
+  if (options.dryRun) {
+    console.log("");
+    console.log("Dry run enabled, no files were modified.");
+  }
+};
+const INIT_PACKAGE_IDS = new Set(DEFAULT_INIT_PACKAGE_IDS);
+const resolveDefaultSourceRoot = (cwd, options) => {
+  if (options.srcDir) {
+    return options.srcDir;
+  }
+  if (options.target) {
+    return options.target;
+  }
+  return fs.existsSync(path.join(cwd, "src")) ? "./web" : "./src";
+};
+const normalizeOptionalAnswer = (value) => {
+  const trimmed = value.trim();
+  return trimmed.length ? trimmed : null;
+};
+const askString = async (readline, question, defaultValue) => {
+  const answer = normalizeOptionalAnswer(await readline.question(`${question} [${defaultValue}]: `));
+  return answer ?? defaultValue;
+};
+const askBoolean = async (readline, question, defaultValue) => {
+  const suffix = "Y/n";
+  while (true) {
+    const answer = normalizeOptionalAnswer(await readline.question(`${question} [${suffix}]: `));
+    if (answer === null) {
+      return defaultValue;
+    }
+    if (/^(y|yes|д|да)$/iu.test(answer)) {
+      return true;
+    }
+    if (/^(n|no|н|нет)$/iu.test(answer)) {
+      return false;
+    }
+    console.error("Введите yes/no или нажмите Enter для значения по умолчанию.");
+  }
+};
+const askPackageManager = async (readline, detectedPackageManager, explicitPackageManager) => {
+  if (explicitPackageManager) {
+    return explicitPackageManager;
+  }
+  const defaultPackageManager = detectedPackageManager ?? "npm";
+  while (true) {
+    const answer = await askString(
+      readline,
+      `Package manager (${PACKAGE_MANAGERS.join("/")})`,
+      defaultPackageManager
+    );
+    if (PACKAGE_MANAGERS.includes(answer)) {
+      return answer;
+    }
+    console.error(`Unknown package manager: ${answer}`);
+  }
+};
+const askPackages = async (readline, options) => {
+  if (options.packages) {
+    return options.packages;
+  }
+  const defaultPackageIds = [...DEFAULT_INIT_PACKAGE_IDS, ...options.with ?? []];
+  console.log("Пакеты для init:");
+  for (const selectedPackage of INSTALLABLE_PACKAGES.filter((entry) => INIT_PACKAGE_IDS.has(entry.id))) {
+    console.log(`  - ${selectedPackage.id}: ${selectedPackage.name}`);
+    console.log(`    ${selectedPackage.description}`);
+  }
+  while (true) {
+    const answer = await askString(
+      readline,
+      "Пакеты через запятую",
+      defaultPackageIds.join(",")
+    );
+    const tokens = parsePackageList(answer);
+    try {
+      const selectedPackages = resolveInstallPackages(tokens);
+      if (selectedPackages.some((selectedPackage) => selectedPackage.id === "testing")) {
+        throw new Error("@retailcrm/embed-ui-v1-testing is not published for public init yet");
+      }
+      return tokens;
+    } catch (error) {
+      console.error(error instanceof Error ? error.message : String(error));
+    }
+  }
+};
+const resolveInteractiveInitOptions = async (cwd, options, detectedPackageManager) => {
+  if (!options.interactive) {
+    return options;
+  }
+  if (!process$1.stdin.isTTY || !process$1.stdout.isTTY) {
+    throw new Error("Interactive init mode requires a TTY. Use explicit flags or omit --interactive.");
+  }
+  const readline = createInterface({
+    input: process$1.stdin,
+    output: process$1.stdout
+  });
+  try {
+    const nextOptions = { ...options };
+    if (!nextOptions.agentsOnly) {
+      const defaultSourceRoot = resolveDefaultSourceRoot(cwd, nextOptions);
+      const sourceRoot = await askString(readline, "Frontend source root", defaultSourceRoot);
+      if (nextOptions.srcDir) {
+        nextOptions.srcDir = sourceRoot;
+      } else {
+        nextOptions.target = sourceRoot;
+      }
+      nextOptions.packages = await askPackages(readline, nextOptions);
+      nextOptions.noConfigs = nextOptions.noConfigs || !await askBoolean(readline, "Создать базовые конфиги", true);
+      nextOptions.noTemplate = nextOptions.noTemplate || !await askBoolean(readline, "Создать стартовый шаблон", true);
+    }
+    nextOptions.packageManager = await askPackageManager(
+      readline,
+      detectedPackageManager,
+      nextOptions.packageManager
+    );
+    nextOptions.noAgents = nextOptions.noAgents || !await askBoolean(readline, "Обновить AGENTS.md", true);
+    nextOptions.noMcp = nextOptions.noMcp || !await askBoolean(readline, "Добавить MCP-настройки", true);
+    if (!nextOptions.agentsOnly) {
+      nextOptions.noInstall = nextOptions.noInstall || !await askBoolean(readline, "Запустить установку зависимостей", true);
+    }
+    return nextOptions;
+  } finally {
+    readline.close();
+  }
+};
+const DEFAULT_INIT_DIRS = ["endpoint", "pages", "widgets", "shared", "i18n"];
+const detectPackageManagerByLockfile = (cwd) => {
+  const knownLockfiles = [
+    { packageManager: "yarn", file: "yarn.lock" },
+    { packageManager: "npm", file: "package-lock.json" },
+    { packageManager: "pnpm", file: "pnpm-lock.yaml" },
+    { packageManager: "bun", file: "bun.lockb" }
+  ];
+  const lockfiles = knownLockfiles.filter(({ file }) => fs.existsSync(path.join(cwd, file)));
+  return lockfiles.length === 1 ? lockfiles[0].packageManager : null;
+};
+const resolvePackageManagerVersion = (packageManager) => {
+  try {
+    return execFileSync(packageManager, ["--version"], {
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "ignore"]
+    }).trim();
+  } catch {
+    return null;
+  }
+};
+const promptForPackageManager = async () => {
+  const readline = createInterface({
+    input: process$1.stdin,
+    output: process$1.stdout
+  });
+  try {
+    while (true) {
+      const answer = await readline.question("Choose package manager (yarn/npm/pnpm/bun): ");
+      if (PACKAGE_MANAGERS.includes(answer)) {
+        return answer;
+      }
+      console.error(`Unknown package manager: ${answer}`);
+    }
+  } finally {
+    readline.close();
+  }
+};
+const resolvePackageManager = async (cwd, explicitPackageManager) => {
+  if (explicitPackageManager) {
+    if (!PACKAGE_MANAGERS.includes(explicitPackageManager)) {
+      throw new Error(`Unknown package manager: ${explicitPackageManager}`);
+    }
+    return explicitPackageManager;
+  }
+  const packageManager = detectPackageManagerByLockfile(cwd);
+  if (packageManager) {
+    return packageManager;
+  }
+  if (process$1.stdin.isTTY && process$1.stdout.isTTY) {
+    return promptForPackageManager();
+  }
+  return "npm";
+};
+const resolveInitPackages = (tokens, extraTokens) => {
+  const packageIds = tokens ?? [...DEFAULT_INIT_PACKAGE_IDS, ...extraTokens ?? []];
+  const packages = resolveInstallPackages(packageIds);
+  for (const selectedPackage of packages) {
+    if (selectedPackage.id === "testing") {
+      throw new Error("@retailcrm/embed-ui-v1-testing is not published for public init yet");
+    }
+  }
+  return packages;
+};
+const resolveInitCwd = (options) => {
+  const cwd = path.resolve(options.cwd);
+  if (!fs.existsSync(cwd)) {
+    throw new Error(`cwd does not exist: ${cwd}`);
+  }
+  if (!fs.statSync(cwd).isDirectory()) {
+    throw new Error(`cwd is not a directory: ${cwd}`);
+  }
+  return cwd;
+};
+const resolveInitSourceRoot = (cwd, options) => {
+  if (options.srcDir) {
+    return path.resolve(cwd, options.srcDir);
+  }
+  if (options.target) {
+    return path.resolve(cwd, options.target);
+  }
+  const srcPath = path.join(cwd, "src");
+  if (!fs.existsSync(srcPath)) {
+    return srcPath;
+  }
+  return path.join(cwd, "web");
+};
+const runUpdate = (options) => {
+  const version = options.version ?? resolveLatestVersion();
+  const packageJsonPaths = collectPackageJsonPaths(options.target);
+  const reports = [];
+  for (const packageJsonPath of packageJsonPaths) {
+    const { formatting, packageJson } = readPackageJson(packageJsonPath);
+    const updates = updatePackageJson(packageJson, version, options.exact);
+    if (updates.length === 0) {
+      continue;
+    }
+    if (!options.dryRun) {
+      writePackageJson(packageJsonPath, packageJson, formatting);
+    }
+    reports.push({ packageJsonPath, updates });
+  }
+  if (reports.length === 0) {
+    console.log(`No ${ROOT_PACKAGE}* dependencies found or changed under ${path.resolve(options.target)}`);
+    return;
+  }
+  const totalUpdates = reports.reduce((sum, report) => sum + report.updates.length, 0);
+  console.log(`Resolved version: ${version}`);
+  for (const report of reports) {
+    console.log(report.packageJsonPath);
+    printChanges(report.updates);
+  }
+  if (options.dryRun) {
+    console.log("Dry run enabled, package.json files were not modified");
+    return;
+  }
+  console.log(
+    `Updated ${totalUpdates} dependency entries in ${reports.length} package.json file(s) under ${path.resolve(options.target)}`
+  );
+};
+const runAdd = async (options) => {
+  const version = options.version ?? resolveLatestVersion();
+  const packageJsonPath = resolvePackageJsonPath(path.resolve(options.target));
+  const { formatting, packageJson } = readPackageJson(packageJsonPath);
+  const selectedPackages = options.packages ? resolveInstallPackages(options.packages) : await promptForInstallSelection(packageJson);
+  if (selectedPackages.length === 0) {
+    console.log("Nothing selected, package.json was not modified");
+    return;
+  }
+  const updates = installPackages(packageJson, selectedPackages, version, options.exact);
+  if (updates.length === 0) {
+    console.log(`Selected packages are already installed with matching ranges in ${packageJsonPath}`);
+    return;
+  }
+  console.log(`Resolved version: ${version}`);
+  console.log(packageJsonPath);
+  printChanges(updates);
+  if (options.dryRun) {
+    console.log("Dry run enabled, package.json was not modified");
+    return;
+  }
+  writePackageJson(packageJsonPath, packageJson, formatting);
+  console.log(`Installed ${updates.length} package entries in ${packageJsonPath}`);
+};
+const applyInitPackageJson = (cwd, selectedPackages, version, packageManager, options, changes) => {
+  const packageJsonPath = path.join(cwd, "package.json");
+  const {
+    created,
+    formatting,
+    packageJson
+  } = readOrCreatePackageJson(packageJsonPath);
+  if (!packageJson.type) {
+    packageJson.type = "module";
+    changes.packageJson.push({ type: "field", name: "type", nextRange: "module" });
+  } else if (packageJson.type !== "module") {
+    changes.warnings.push('package.json already has type field and it is not "module"');
+  }
+  setMissingScript(packageJson, "build", "vite build", changes);
+  setMissingScript(packageJson, "eslint", "eslint .", changes);
+  setMissingScript(packageJson, "eslint:fix", "eslint --fix .", changes);
+  setMissingScript(packageJson, "publish-extension", "node scripts/publish-extension.mjs", changes);
+  for (const selectedPackage of selectedPackages) {
+    setDependency(
+      packageJson,
+      selectedPackage.section,
+      selectedPackage.name,
+      createRange(version, options.exact),
+      changes,
+      options
+    );
+  }
+  for (const dependency of INIT_RUNTIME_DEPENDENCIES) {
+    if (dependency.name === I18N_RUNTIME_DEPENDENCY && hasExistingDependency(packageJson, dependency.name)) {
+      changes.skipped.push(`${dependency.name} already exists; i18n dependency setup skipped to avoid conflicts with existing project configuration`);
+      continue;
+    }
+    setDependency(packageJson, "dependencies", dependency.name, dependency.range, changes, options);
+  }
+  for (const dependency of INIT_DEV_DEPENDENCIES) {
+    setDependency(packageJson, "devDependencies", dependency.name, dependency.range, changes, options);
+  }
+  if (!packageJson.packageManager && options.packageManager) {
+    const packageManagerVersion = resolvePackageManagerVersion(packageManager);
+    if (packageManagerVersion) {
+      const nextPackageManager = `${packageManager}@${packageManagerVersion}`;
+      packageJson.packageManager = nextPackageManager;
+      changes.packageJson.push({
+        type: "field",
+        name: "packageManager",
+        nextRange: nextPackageManager
+      });
+    } else {
+      changes.warnings.push(`Cannot resolve ${packageManager} version; packageManager field was not written`);
+    }
+  }
+  if (!options.dryRun && (created || changes.packageJson.length > 0)) {
+    writePackageJson(packageJsonPath, packageJson, formatting);
+  }
+  return packageJsonPath;
+};
+const applyInitDirectories = (sourceRoot, options, changes) => {
+  if (options.noDirs || options.agentsOnly) {
+    return;
+  }
+  const dirs = options.dirs ?? DEFAULT_INIT_DIRS;
+  const unknownDir = dirs.find((dir) => ![...DEFAULT_INIT_DIRS, "src", "tests"].includes(dir));
+  if (unknownDir) {
+    throw new Error(`Unknown directory preset: ${unknownDir}`);
+  }
+  ensureDirectory(sourceRoot, options, changes);
+  for (const dir of dirs) {
+    if (dir === "src") {
+      continue;
+    }
+    ensureDirectory(path.join(sourceRoot, dir), options, changes);
+  }
+  if (dirs.includes("i18n")) {
+    ensureDirectory(path.join(sourceRoot, "i18n/locales"), options, changes);
+  }
+};
+const applyInitConfigs = (cwd, sourceRoot, options, changes) => {
+  if (options.noConfigs || options.agentsOnly) {
+    return;
+  }
+  writeFileIfAllowed(path.join(cwd, "tsconfig.json"), createTsConfig(cwd, sourceRoot), options, changes);
+  writeFileIfAllowed(path.join(cwd, "vite.config.ts"), createViteConfig(cwd, sourceRoot), options, changes);
+  writeFileIfAllowed(path.join(cwd, "env.d.ts"), createEnvDts(), options, changes);
+  writeFileIfAllowed(path.join(cwd, "eslint.config.js"), createEslintConfig(cwd, sourceRoot), options, changes);
+};
+const applyInitTemplate = (cwd, sourceRoot, packageManager, options, changes) => {
+  if (options.noTemplate || options.agentsOnly) {
+    return;
+  }
+  if (options.template !== "order-card") {
+    throw new Error(`Unknown template: ${options.template}`);
+  }
+  writeFileIfAllowed(
+    path.join(sourceRoot, "endpoint/endpoint.worker.ts"),
+    createEndpointWorker(options),
+    options,
+    changes
+  );
+  writeFileIfAllowed(path.join(sourceRoot, "shared/assets/extension.svg"), createExtensionIcon(), options, changes);
+  writeFileIfAllowed(path.join(sourceRoot, "i18n/index.ts"), createI18nIndex(), options, changes);
+  writeFileIfAllowed(path.join(sourceRoot, "i18n/locales/en-GB.json"), createMessages(), options, changes);
+  writeFileIfAllowed(path.join(sourceRoot, "i18n/locales/es-ES.json"), createMessages(), options, changes);
+  writeFileIfAllowed(path.join(sourceRoot, "i18n/locales/ru-RU.json"), createMessages(), options, changes);
+  writeFileIfAllowed(path.join(sourceRoot, "pages/SettingsPage.vue"), createSettingsPage(), options, changes);
+  writeFileIfAllowed(path.join(sourceRoot, "widgets/OrderCommonAfterWidget.vue"), createOrderWidget(), options, changes);
+  writeFileIfAllowed(path.join(cwd, "extensionrc.json"), createExtensionConfig(options), options, changes);
+  writeFileIfAllowed(path.join(cwd, "scripts/publish-extension.mjs"), createPublishScript(), options, changes);
+  writeFileIfAllowed(path.join(cwd, "README.md"), createReadme(cwd, sourceRoot, options, packageManager), options, changes);
+};
+const runInstall = (cwd, packageManager, options, changes, packageJsonChanged) => {
+  if (options.noInstall || options.agentsOnly) {
+    return;
+  }
+  if (!packageJsonChanged && !options.force) {
+    changes.skipped.push("install skipped because package.json was not changed");
+    return;
+  }
+  const args = ["install"];
+  changes.install = `${packageManager} ${args.join(" ")}`;
+  if (options.dryRun) {
+    return;
+  }
+  execFileSync(packageManager, args, {
+    cwd,
+    stdio: "inherit"
+  });
+};
+const runInit = async (options) => {
+  const cwd = resolveInitCwd(options);
+  const interactiveOptions = await resolveInteractiveInitOptions(
+    cwd,
+    options,
+    detectPackageManagerByLockfile(cwd)
+  );
+  const sourceRoot = resolveInitSourceRoot(cwd, interactiveOptions);
+  if (fs.existsSync(sourceRoot) && !fs.statSync(sourceRoot).isDirectory()) {
+    throw new Error(`Target path is not a directory: ${sourceRoot}`);
+  }
+  const selectedPackages = resolveInitPackages(interactiveOptions.packages, interactiveOptions.with);
+  const version = interactiveOptions.agentsOnly ? interactiveOptions.version ?? "not used" : interactiveOptions.version ?? resolveLatestVersion();
+  const packageManager = interactiveOptions.agentsOnly ? interactiveOptions.packageManager ?? detectPackageManagerByLockfile(cwd) ?? "npm" : await resolvePackageManager(cwd, interactiveOptions.packageManager);
+  const changes = createInitChanges();
+  applyInitPreflight(cwd, sourceRoot, packageManager, selectedPackages, version, interactiveOptions, changes);
+  let packageJsonPath = null;
+  if (!interactiveOptions.agentsOnly) {
+    packageJsonPath = applyInitPackageJson(cwd, selectedPackages, version, packageManager, interactiveOptions, changes);
+    applyInitDirectories(sourceRoot, interactiveOptions, changes);
+    applyInitConfigs(cwd, sourceRoot, interactiveOptions, changes);
+    applyInitTemplate(cwd, sourceRoot, packageManager, interactiveOptions, changes);
+    applyInitPackageConfigHooks(cwd, selectedPackages, packageManager, interactiveOptions, changes);
+  }
+  applyInitAgents(cwd, selectedPackages, packageManager, interactiveOptions, changes);
+  runInstall(cwd, packageManager, interactiveOptions, changes, Boolean(packageJsonPath && changes.packageJson.length > 0));
+  printInitReport(cwd, sourceRoot, version, packageManager, changes, interactiveOptions);
+};
+const main = async (argv = process$1.argv.slice(2)) => {
+  const options = parseArgs(argv);
+  if (options.command === "init") {
+    await runInit(options);
+    return;
+  }
+  if (options.add) {
+    await runAdd(options);
+    return;
+  }
+  runUpdate(options);
+};
+const isExecutedDirectly = () => {
+  const entryPath = process$1.argv[1];
+  if (!entryPath) {
+    return false;
+  }
+  return pathToFileURL(path.resolve(entryPath)).href === import.meta.url;
+};
+if (isExecutedDirectly()) {
+  try {
+    await main();
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    console.error(message);
+    process$1.exit(1);
+  }
+}
+export {
+  main,
+  parseArgs,
+  parseInitArgs,
+  runAdd,
+  runInit,
+  runUpdate
+};