@coraltravelcenter/b2c-landing-builder 2.10.1 → 2.12.0

package/README.md

@@ -22,42 +22,27 @@ b2c-landing-vite check
 b2c-landing-vite dev
 b2c-landing-vite build
 b2c-landing-vite deploy
-b2c-landing-vite deploy --dry-run
-b2c-landing-vite deploy --update
-b2c-landing-vite deploy --relink
-b2c-landing-vite deploy --publish
 b2c-landing-vite deploy --section hero
-b2c-landing-vite deploy --remote
-b2c-landing-vite deploy --force
-b2c-landing-vite deploy --assets-only
-b2c-landing-vite deploy --assets-only --prune-assets
+b2c-landing-vite deploy assets
 b2c-landing-vite block:add hero
 b2c-landing-vite block:rename hero main-hero
 b2c-landing-vite update
 ```
 
 - `check` проверяет конфигурацию, `order.json` и контракт JS-блоков.
-- `dev` запускает Vite и userscript для Tampermonkey.
+- `dev` запускает Vite и отдельный userscript с названием проекта для
+  Tampermonkey.
 - `build` создаёт CMS-файлы в `@CMS/` и переписывает пути ассетов на CDN.
-- `deploy --assets-only` выполняет свежую сборку и загружает только изменённые
-  deploy-ассеты. При первом запуске builder запрашивает backoffice-логин и
-  скрытый пароль через ADFS. На диск сохраняется только токен (не пароль), токен
-  автоматически используется до истечения. Для CI можно передать
+- `deploy` собирает проект, проверяет ассеты на CDN и разворачивает CMS-виджеты.
+- `deploy --section <key>` разворачивает только выбранную CMS-секцию, не изменяя
+  и не удаляя соседние секции.
+- `deploy assets` собирает проект и синхронизирует ассеты с B2C CDN.
+- При первом deploy builder запрашивает backoffice-логин и скрытый пароль через
+  ADFS. На диск сохраняется только токен. Для CI можно передать
   `B2C_BACKOFFICE_TOKEN`.
 - Backoffice-запросы ограничены 30 секундами. Безопасные GET-запросы повторяются
   до двух раз при сетевом сбое, timeout, HTTP 429, 502, 503 или 504. Изменяющие
   CMS запросы автоматически не повторяются, чтобы не создать дубликаты.
-- `deploy` при первом запуске предлагает выбрать application, layout и HTML-зону,
-  создаёт CMS-страницу и размещает блоки в порядке `order.json`. При повторном
-  запуске для опубликованной страницы создаётся checkout-версия.
-- `deploy --dry-run` выполняет свежую локальную сборку, читает состояние CMS и
-  показывает точный план загрузки ассетов, создания версии и изменений виджетов.
-  Страница, виджеты, ассеты и локальный deploy-state при этом не изменяются.
-- `deploy --assets-only --dry-run` показывает только план синхронизации ассетов.
-- `deploy --update` обновляет сохранённую версию страницы без создания новой.
-- `deploy --section <key>` меняет только блок с ключом из `order.json`. Builder
-  берёт за основу актуальную remote-страницу, поэтому локальные копии соседних
-  секций не попадают в payload и не могут затереть изменения из CMS.
 - После успешного deploy builder сохраняет снимок секций в `.b2c/deploy/` как
   достоверный `base`. Следующий deploy структурно сравнивает секции `local`,
   актуальный `remote` и `base`. Изменения разных секций объединяются; изменение
@@ -65,28 +50,13 @@ b2c-landing-vite update
 - Если `base` ещё отсутствует, отличие local от remote считается потенциальным
   конфликтом. Обычный deploy не выполняет silent overwrite и предлагает явно
   сохранить CMS-версию, применить local или отменить операцию.
-- `deploy --remote` не перезаписывает конфликтующие секции локальной версией.
-  `deploy --force` осознанно выбирает local. Для section deploy обе стратегии
-  ограничены выбранной секцией: `deploy --section hero --remote` или
-  `deploy --section hero --force`; соседние remote-секции сохраняются.
-- `deploy --relink` восстанавливает или меняет привязку проекта к существующей
-  CMS-странице. Builder предлагает application, поиск страницы по названию или
-  URL, версию, HTML-зону и точную позицию. Обычный запуск создаёт checkout для
-  опубликованной версии; вместе с `--update` выбранная версия меняется на месте.
-- `deploy --relink --dry-run` проходит тот же интерактивный выбор и показывает
-  план, но не сохраняет новую привязку и не изменяет CMS.
-- `deploy --publish` после успешной синхронизации виджетов публикует выбранную
-  версию. Публикация блокируется, если в Backoffice не заполнены title, URL,
-  SEO title или SEO description; builder не придумывает метаданные сам.
-- `deploy --assets-only --prune-assets` удаляет из CMS только отсутствующие в
-  текущей сборке файлы, которые этот builder сам загрузил и записал как
-  управляемые в deploy-state проекта. Уже существовавшие в CMS файлы не
-  считаются управляемыми и не удаляются. Команда
-  намеренно отделена от обычного deploy и никогда не удаляет неизвестные файлы.
-  Сначала рекомендуется запустить её с `--dry-run`.
-- Перед любым deploy сохранённые pageContentId и layoutAreaId сверяются с CMS.
-  Устаревшая привязка останавливает операцию до загрузки файлов и предлагает
-  `deploy --relink`.
+- Стабильные `pageId`, `layoutAreaId` и позиция сохраняются отдельно в
+  `.b2c/deploy/<site>--<folder>.binding.json`. Этот файл можно хранить в Git,
+  чтобы команда находила ту же CMS-страницу после нового клонирования проекта.
+- Перед deploy builder получает список версий сохранённой страницы. Published
+  выбирается по умолчанию; из Published или Unpublished создаётся checkout,
+  существующий Checkout обновляется напрямую. Потерянную привязку можно
+  восстановить интерактивным выбором существующей страницы.
 - Одновременные deploy одного проекта на компьютере блокируются lock-файлом в
   `.b2c/deploy/`; аварийно оставленный lock автоматически признаётся устаревшим.
 - Непосредственно перед первой записью CMS-состояние читается повторно. Если оно
@@ -95,14 +65,15 @@ b2c-landing-vite update
 - `block:rename` атомарно переименовывает все файлы блока и обновляет порядок.
 - `update` проверяет npm registry и показывает команду ручного обновления.
 
-После успешного выполнения рабочих команд builder коротко проверяет npm
-registry. Если доступна новая стабильная версия, терминал показывает текущую и
-новую версии и команду ручного обновления. Ошибки сети не влияют на работу CLI.
-Builder никогда не обновляется автоматически:
+После успешного выполнения рабочих команд builder коротко и независимо
+проверяет в npm registry версии самого builder и шаблона проекта. Для проекта
+без `template.version` шаблон помечается как `legacy`. Ошибки сети не влияют на
+работу CLI; ничего не обновляется автоматически:
 
 ```bash
 b2c-landing-vite update
 # Update manually: npm install --global @coraltravelcenter/b2c-landing-builder@latest
+# Update project template: npx @coraltravelcenter/create-b2c-landing-vite@latest migrate
 ```
 
 ## Создание проекта
@@ -126,6 +97,9 @@ export default {
   builder: {
     minVersion: "2.10.0",
   },
+  template: {
+    version: "2.13.0",
+  },
   project: {
     name: "uae-promo",
   },
@@ -140,6 +114,10 @@ export default {
 };
 ```
 
+`template.version` записывается генератором и показывает, какой версией шаблона
+создан проект. Для старых проектов поле необязательно; его отсутствие позволяет
+builder распознать legacy-шаблон и предложить миграцию в будущих версиях.
+
 Имя проекта должно соответствовать `^[a-z0-9][a-z0-9-]*$`.
 
 Поддерживаются:
@@ -167,6 +145,15 @@ Monkey URL, контейнер и CDN prefix не задаются вручну
 - контейнер: `#monkey-app`;
 - CDN prefix: `landing-pages/<project.name>`.
 
+Dev-сервер начинает с `127.0.0.1:5173` и автоматически выбирает следующий
+свободный порт, поэтому несколько проектов можно запускать одновременно. Если
+задан `B2C_PORT`, порт считается обязательным и занятое значение завершает
+команду ошибкой.
+
+Userscript ограничен доменом выбранного бренда и дополнительно проверяет hostname
+перед монтированием. Namespace также содержит бренд, поэтому Coral и Sunmar не
+конфликтуют даже при одинаковом названии проекта.
+
 Для Coral и Sunmar настроены отдельные production CDN. Команда `build`
 автоматически выбирает CDN по `site.preset`.
 
@@ -242,11 +229,41 @@ build; дополнительные контейнеры builder не созда
 }
 ```
 
-В dev пути направляются на `http://127.0.0.1:5173`. При production build они
-преобразуются в `<assetsBase>/landing-pages/<project.name>/...`. Builder
+В dev пути направляются на фактический origin текущего Vite-сервера. При
+production build они
+преобразуются в `<assetsBase>/landing-pages/<folder>/...`. Builder
 переписывает только изображения `jpg`, `jpeg`, `png`, `webp`, `avif`, `gif` и
 `svg`; остальные root-relative ресурсы не изменяются.
 
+### Deploy assets
+
+```bash
+b2c-landing-vite deploy assets
+```
+
+Команда выполняет свежую сборку, сравнивает build manifest с deploy-state и CDN,
+а затем показывает план загрузки. Перед отправкой файлов требуется явное
+подтверждение; по умолчанию выбран отказ.
+
+Вложенная структура `public/` сохраняется на CDN. Например,
+`public/hotels/gallery/room.webp` загружается как
+`landing-pages/<folder>/hotels/gallery/room.webp`.
+
+Существующие CDN-файлы не перезаписываются и не удаляются. Если содержимое
+изменилось, файл нужно переименовать, чтобы опубликовать его по новому URL.
+Deploy-state обновляется атомарно только после успешной загрузки всех файлов.
+В итоговом блоке команда также выводит корневой URL `CDN folder`, например
+`https://b2ccdn.coral.ru/content/landing-pages/uae-promo/`.
+
+Обычный `deploy` не загружает ассеты. Он проверяет наличие всех файлов build
+manifest на CDN и останавливается до изменения CMS, если сначала требуется
+выполнить `deploy assets`.
+
+Перед изменением CMS команда показывает план добавления, обновления, удаления и
+перестановки управляемых виджетов. Подтверждение и последующее предложение
+публикации по умолчанию имеют значение `No`. После deploy выводятся Preview и
+прямая ссылка на созданную checkout-версию в BackOffice.
+
 ## Совместимость
 
 Builder проверяет `schemaVersion` до запуска команд. Несовместимая версия схемы

package/bin/b2c-landing-vite.mjs

@@ -9,7 +9,9 @@ runCli(args).then(async () => {
   if (!command || ["help", "--help", "-h", "update"].includes(command)) return;
 
   const {printUpdateNotice} = await import("../src/update/check-update.mjs");
-  await printUpdateNotice();
+  const {loadConfig} = await import("../src/config/load-config.mjs");
+  const config = await loadConfig().catch(() => null);
+  await printUpdateNotice({templateVersion: config?.template?.version});
 }).catch((error) => {
   console.error(`[b2c-landing-vite] ${error.message}`);
   process.exitCode = 1;

package/npm-shrinkwrap.json

@@ -1,12 +1,12 @@
 {
   "name": "@coraltravelcenter/b2c-landing-builder",
-  "version": "2.10.1",
+  "version": "2.12.0",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "@coraltravelcenter/b2c-landing-builder",
-      "version": "2.10.1",
+      "version": "2.12.0",
       "license": "MIT",
       "dependencies": {
         "@babel/parser": "7.28.6",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@coraltravelcenter/b2c-landing-builder",
-  "version": "2.10.1",
+  "version": "2.12.0",
   "description": "CLI and build toolkit for B2C landing projects",
   "type": "module",
   "bin": {

package/src/cli/index.mjs

@@ -8,16 +8,8 @@ Commands:
   dev                       Start the Vite development server
   build                     Build CMS-ready HTML files
   deploy                    Build, sync assets, and deploy CMS widgets
-  deploy --dry-run          Show the exact deploy plan without changing CMS
-  deploy --update           Update the current CMS version in place
-  deploy --relink           Attach the project to an existing CMS page
-  deploy --publish          Publish after a successful deploy
-  deploy --section <key>    Deploy one section, preserving all other remote sections
-  deploy --force            Explicitly overwrite remote changes in the current scope
-  deploy --remote           Keep remote content when changes conflict
-  deploy --assets-only --prune-assets
-                            Remove obsolete project assets recorded in deploy-state
-  deploy --assets-only      Build and sync assets with the B2C CDN
+  deploy --section <key>    Deploy one CMS section
+  deploy assets             Build and sync assets with the B2C CDN
   check                     Validate project configuration
   block:add <key>           Create a block
   block:rename <old> <new>  Rename a block
@@ -85,56 +77,38 @@ export async function runCli(args) {
     return;
   }
   if (command === "deploy") {
-    const allowed = new Set(["--assets-only", "--update", "--dry-run", "--relink", "--publish", "--prune-assets", "--force", "--remote"]);
-    const flags = new Set(rest.filter((argument) => allowed.has(argument)));
-    const sectionIndex = rest.indexOf("--section");
-    const section = sectionIndex >= 0 ? rest[sectionIndex + 1] : null;
-    const consumed = new Set([...flags, ...(sectionIndex >= 0 ? ["--section", section] : [])]);
-    if (rest.some((argument) => !consumed.has(argument)) || (sectionIndex >= 0 && !section) ||
-      (flags.has("--force") && flags.has("--remote")) ||
-      (flags.has("--assets-only") && (flags.has("--update") || flags.has("--relink") || flags.has("--publish"))) ||
-      (flags.has("--prune-assets") && !flags.has("--assets-only"))) {
-      throw new Error(
-        "Usage: b2c-landing-vite deploy [--section <key>] [--force | --remote] [--update] [--relink] [--publish] [--dry-run]"
-      );
+    const assetsOnly = rest.length === 1 && rest[0] === "assets";
+    const sectionOnly = rest.length === 2 && rest[0] === "--section" && Boolean(rest[1]);
+    if (rest.length && !assetsOnly && !sectionOnly) {
+      throw new Error("Usage: b2c-landing-vite deploy [assets | --section <key>]");
     }
     const config = await loadConfig();
     const project = validateProject(config);
     const preset = resolvePreset(config.site.preset, {requireAssets: true});
     const {withDeploymentLock} = await import("../deploy/lock.mjs");
     return withDeploymentLock({site: preset.id, folder: project.folder}, async () => {
-      await runCli(["build"]);
-      const {getBackofficeToken} = await import("../deploy/auth.mjs");
-      const token = await getBackofficeToken({brand: preset.id});
-      const {deployAssetsOnly, deployProject, planDeployment} = await import("../deploy/deploy.mjs");
-      if (flags.has("--dry-run")) {
-        return planDeployment({
+      if (assetsOnly) {
+        const {deployAssetsCommand} = await import("../deploy/assets-command.mjs");
+        return deployAssetsCommand({
           config,
+          project,
           preset,
-          token,
-          update: flags.has("--update"),
-          assetsOnly: flags.has("--assets-only"),
-          relink: flags.has("--relink"),
-          publish: flags.has("--publish"),
-          pruneAssets: flags.has("--prune-assets"),
+          build: () => runCli(["build"]),
+          getToken: async () => {
+            const {getBackofficeToken} = await import("../deploy/auth.mjs");
+            return getBackofficeToken({brand: preset.id});
+          },
         });
       }
-      if (flags.has("--assets-only")) return deployAssetsOnly({
-        config,
-        preset,
-        token,
-        pruneAssets: flags.has("--prune-assets"),
-      });
+      await runCli(["build"]);
+      const {getBackofficeToken} = await import("../deploy/auth.mjs");
+      const token = await getBackofficeToken({brand: preset.id});
+      const {deployProject} = await import("../deploy/deploy.mjs");
       return deployProject({
         config,
         preset,
         token,
-        update: flags.has("--update"),
-        relink: flags.has("--relink"),
-        publish: flags.has("--publish"),
-        pruneAssets: flags.has("--prune-assets"),
-        section,
-        strategy: flags.has("--force") ? "force" : flags.has("--remote") ? "remote" : "ask",
+        section: sectionOnly ? rest[1] : null,
       });
     });
   }

package/src/config/validate-config.mjs

@@ -33,6 +33,9 @@ export function validateConfig(config) {
       );
     }
   }
+  if (config.template !== undefined && !VERSION_RE.test(config.template?.version || "")) {
+    throw new Error("template.version must be a semantic version such as 2.12.2");
+  }
   if (!PROJECT_NAME_RE.test(config.project?.name || "")) {
     throw new Error("project.name must match ^[a-z0-9][a-z0-9-]*$");
   }

package/src/deploy/assets-command.mjs

@@ -0,0 +1,124 @@
+import {planAssetChanges, uploadChangedAssets} from "./assets.mjs";
+import {BackofficeClient} from "./backoffice-client.mjs";
+import {readBuildManifest} from "./manifest.mjs";
+import {readDeploymentState, writeDeploymentState} from "./state.mjs";
+
+function formatFiles(prefix, files) {
+  return files.map((file) => `${prefix} ${file}`).join("\n");
+}
+
+async function terminalUi() {
+  const {cancel, confirm, intro, isCancel, log, note, outro, spinner} = await import("@clack/prompts");
+  let progress;
+  return {
+    start() {
+      intro("Deploy assets");
+    },
+    built() {
+      log.success("Project built");
+    },
+    checking() {
+      log.step("Checking CDN state");
+    },
+    plan({target, upload, skip, unchanged}) {
+      note(target, "CDN folder");
+      const groups = [];
+      if (upload.length) groups.push(`Upload · ${upload.length}\n${formatFiles("+", upload)}`);
+      if (skip.length) {
+        groups.push(
+          `Skipped · ${skip.length}\n${formatFiles("!", skip)}\n` +
+          "Existing CDN files are immutable. Rename them to publish new versions."
+        );
+      }
+      groups.push(`Unchanged · ${unchanged}`);
+      note(groups.join("\n\n"), "Asset plan");
+    },
+    async confirm(count) {
+      const answer = await confirm({message: `Upload ${count} file${count === 1 ? "" : "s"}?`, initialValue: false});
+      return isCancel(answer) ? false : answer;
+    },
+    uploading(count) {
+      progress = spinner();
+      progress.start(`Uploading ${count} file${count === 1 ? "" : "s"}`);
+    },
+    uploaded(count) {
+      progress?.stop(`Uploaded ${count} file${count === 1 ? "" : "s"}`);
+    },
+    failed(error) {
+      progress?.stop("Upload failed");
+      const uploaded = error.uploaded?.length ? error.uploaded.join(", ") : "none";
+      const failed = error.failed?.length ? error.failed.join(", ") : error.message;
+      log.error(`Uploaded before failure: ${uploaded}\nFailed: ${failed}\nDeploy state was not updated.`);
+    },
+    cancelled() {
+      cancel("Deploy cancelled");
+    },
+    complete({uploaded, skipped, unchanged}) {
+      outro(uploaded || skipped
+        ? `Complete · uploaded ${uploaded} · skipped ${skipped} · unchanged ${unchanged}`
+        : "No asset changes");
+    },
+  };
+}
+
+export async function deployAssetsCommand({
+  config,
+  project,
+  preset,
+  root = process.cwd(),
+  build,
+  getToken,
+  client,
+  ui,
+}) {
+  ui ||= await terminalUi();
+  ui.start();
+  await build();
+  ui.built();
+
+  const manifest = readBuildManifest(root);
+  if (manifest.project !== config.project.name || manifest.site !== preset.id || manifest.folder !== project.folder) {
+    throw new Error("Build manifest does not match the current project. Run build again.");
+  }
+  const token = client ? null : await getToken();
+  const api = client || new BackofficeClient({brand: preset.id, token});
+  const state = readDeploymentState(preset.id, manifest.folder, root);
+  const remoteRoot = new URL(preset.assetsBase).pathname;
+  const target = `${preset.assetsBase}/${manifest.assetsPrefix}/`;
+
+  ui.checking();
+  const plan = await planAssetChanges({
+    manifest,
+    state,
+    remoteRoot,
+    listFiles: api.listFiles.bind(api),
+  });
+  const upload = plan.upload.map((asset) => asset.path);
+  const skip = plan.skip.map((asset) => asset.path);
+  ui.plan({brand: preset.id, target, upload, skip, unchanged: plan.unchanged});
+
+  if (upload.length && !await ui.confirm(upload.length)) {
+    ui.cancelled();
+    return {cancelled: true, plan, target};
+  }
+
+  if (upload.length) ui.uploading(upload.length);
+  let result;
+  try {
+    result = await uploadChangedAssets({
+      manifest,
+      state,
+      root,
+      remoteRoot,
+      uploadFile: api.uploadFile.bind(api),
+      plan,
+    });
+  } catch (error) {
+    ui.failed(error);
+    throw error;
+  }
+  writeDeploymentState(preset.id, manifest.folder, result.state, root);
+  if (upload.length) ui.uploaded(result.uploaded.length);
+  ui.complete({uploaded: result.uploaded.length, skipped: result.skipped.length, unchanged: result.unchanged});
+  return {...result, cancelled: false, target};
+}

package/src/deploy/assets.mjs

@@ -50,6 +50,23 @@ export async function planAssetChanges({manifest, state, listFiles, remoteRoot =
   };
 }
 
+export async function findMissingRemoteAssets({manifest, listFiles, remoteRoot = "/content"}) {
+  const directories = new Map();
+  const namesInDirectory = (directory) => {
+    if (!directories.has(directory)) {
+      directories.set(directory, Promise.resolve(listFiles(directory)).then(filesFromListing));
+    }
+    return directories.get(directory);
+  };
+  const missing = [];
+  await Promise.all(manifest.assets.map(async (asset) => {
+    const remotePath = path.posix.join("/", remoteRoot, manifest.assetsPrefix, asset.path);
+    const names = await namesInDirectory(path.posix.dirname(remotePath));
+    if (!names.has(path.posix.basename(remotePath))) missing.push(asset.path);
+  }));
+  return missing.sort();
+}
+
 export async function uploadChangedAssets({
   manifest,
   state,
@@ -60,10 +77,12 @@ export async function uploadChangedAssets({
   concurrency = 5,
   prune = false,
   deleteFile,
+  plan: preparedPlan,
 }) {
-  const plan = await planAssetChanges({manifest, state, listFiles, remoteRoot, prune});
+  const plan = preparedPlan || await planAssetChanges({manifest, state, listFiles, remoteRoot, prune});
   const assets = {...state.assets};
   const uploaded = [];
+  const failures = [];
   const skipped = plan.skip.map((asset) => asset.path);
   for (const asset of plan.skip) assets[asset.path] = {...asset, immutable: true, managed: false};
   let cursor = 0;
@@ -73,14 +92,29 @@ export async function uploadChangedAssets({
       const asset = plan.upload[cursor++];
       const localPath = path.join(root, ...(manifest.assetsDirectory || "public").split("/"), ...asset.path.split("/"));
       const remotePath = path.posix.join("/", remoteRoot, manifest.assetsPrefix, asset.path);
-      const result = await uploadFile(remotePath, localPath);
-      assets[asset.path] = {...asset, url: result?.files?.[0]?.url, managed: true};
-      uploaded.push(asset.path);
+      try {
+        const result = await uploadFile(remotePath, localPath);
+        assets[asset.path] = {...asset, url: result?.files?.[0]?.url, managed: true};
+        uploaded.push(asset.path);
+      } catch (error) {
+        failures.push({path: asset.path, error});
+      }
     }
   }
 
   const workerCount = Math.min(Math.max(1, concurrency), plan.upload.length || 1);
   await Promise.all(Array.from({length: workerCount}, () => worker()));
+  if (failures.length) {
+    const reasons = [...new Set(failures.map((failure) => failure.error?.message).filter(Boolean))];
+    const error = new AggregateError(
+      failures.map((failure) => failure.error),
+      `Failed to upload ${failures.length} asset${failures.length === 1 ? "" : "s"}` +
+      (reasons.length ? `: ${reasons.join("; ")}` : "")
+    );
+    error.uploaded = uploaded.sort();
+    error.failed = failures.map((failure) => failure.path).sort();
+    throw error;
+  }
   const removed = [];
   if (prune && plan.remove.length) {
     if (!deleteFile) throw new Error("CMS asset deletion is unavailable");

package/src/deploy/auth.mjs

@@ -89,8 +89,17 @@ async function responseJson(response, label) {
 
 export async function authenticateAdfs({brand, login, password, fetchImpl = globalThis.fetch}) {
   const apiBase = `https://b2capi.${brand}.ru/BackOffice/Adfs`;
+  let redirectResponse;
+  try {
+    redirectResponse = await fetchImpl(`${apiBase}/GetRedirectToAdfsUrl`);
+  } catch (error) {
+    throw new Error(
+      `Backoffice is unavailable. Connect to the office network or VPN. ${error.message}`,
+      {cause: error}
+    );
+  }
   const redirectPayload = await responseJson(
-    await fetchImpl(`${apiBase}/GetRedirectToAdfsUrl`),
+    redirectResponse,
     "Getting ADFS login URL"
   );
   const loginUrl = redirectPayload?.result?.url;
@@ -139,11 +148,12 @@ export async function getBackofficeToken({
   brand,
   env = process.env,
   fetchImpl = globalThis.fetch,
-  cachePath = defaultCachePath(),
+  cachePath,
   credentialsProvider = promptCredentials,
   now = Date.now(),
 } = {}) {
   if (env.B2C_BACKOFFICE_TOKEN) return env.B2C_BACKOFFICE_TOKEN;
+  cachePath ||= env.B2C_AUTH_CACHE || defaultCachePath();
   const cache = readCache(cachePath);
   const existing = cachedToken(cache, brand, now);
   if (existing) return existing;

package/src/deploy/deploy.mjs

@@ -1,7 +1,12 @@
-import {planAssetChanges, uploadChangedAssets} from "./assets.mjs";
+import {findMissingRemoteAssets, planAssetChanges, uploadChangedAssets} from "./assets.mjs";
 import {BackofficeClient} from "./backoffice-client.mjs";
 import {readBuildManifest} from "./manifest.mjs";
-import {readDeploymentState, writeDeploymentState} from "./state.mjs";
+import {
+  readDeploymentBinding,
+  readDeploymentState,
+  writeDeploymentBinding,
+  writeDeploymentState,
+} from "./state.mjs";
 import {resolveSections, summarizeChanges} from "./reconcile.mjs";
 import {
   createPagePlacement,
@@ -10,8 +15,10 @@ import {
   publicationIssues,
   publishPage,
   selectExistingPagePlacement,
+  selectBoundPagePlacement,
   selectNewPagePlacement,
   validateSavedPlacement,
+  versionLabel,
 } from "./page.mjs";
 import {localSections, planWidgetChanges, remoteSections, syncWidgets} from "./widgets.mjs";
 
@@ -23,6 +30,61 @@ function logList(log, label, items) {
   log(`[dry-run] ${label}: ${items.length ? items.join(", ") : "none"}`);
 }
 
+async function terminalDeployUi() {
+  const {confirm, intro, isCancel, log, note, outro, select, text} = await import("@clack/prompts");
+  const answer = async (promise) => {
+    const value = await promise;
+    if (isCancel(value)) throw new Error("Deploy cancelled");
+    return value;
+  };
+  const list = (prefix, items) => items.map((item) => `${prefix} ${item}`).join("\n");
+  return {
+    start: () => intro("Deploy"),
+    text: (options) => answer(text(options)),
+    select: (options) => answer(select(options)),
+    plan({page, version, add, update, remove, reorder, section}) {
+      note(`${page}\n${version}${section ? `\nSection: ${section}` : ""}`, "CMS target");
+      const groups = [];
+      if (add.length) groups.push(`Add · ${add.length}\n${list("+", add)}`);
+      if (update.length) groups.push(`Update · ${update.length}\n${list("~", update)}`);
+      if (remove.length) groups.push(`Remove · ${remove.length}\n${list("-", remove)}`);
+      if (reorder.length) groups.push(`Reorder · ${reorder.length}\n${list("↕", reorder)}`);
+      if (!groups.length) groups.push("No widget changes");
+      note(groups.join("\n\n"), "Widget plan");
+    },
+    confirmApply: () => answer(confirm({message: "Apply these changes?", initialValue: false})),
+    confirmPublish: () => answer(confirm({message: "Publish this page version?", initialValue: false})),
+    info: (message) => log.info(message),
+    complete({widgets, preview, backoffice, live}) {
+      const lines = [
+        `Added ${widgets.added} · updated ${widgets.updated} · removed ${widgets.removed} · reordered ${widgets.reordered}`,
+        preview ? `\nPreview\n${preview}` : null,
+        backoffice ? `\nBackOffice\n${backoffice}` : null,
+        live ? `\nLive\n${live}` : null,
+      ].filter(Boolean);
+      outro(lines.join("\n"));
+    },
+  };
+}
+
+function scopedWidgetPlan(plan, section) {
+  if (!section) return plan;
+  const matches = (title) => title.endsWith(` | ${section}`);
+  return {
+    add: plan.add.filter(matches),
+    update: plan.update.filter(matches),
+    remove: plan.remove.filter(matches),
+    reorder: plan.reorder.filter((item) => matches(item.title)),
+  };
+}
+
+function backofficePageUrl(preset, pageContentId) {
+  if (!preset.backofficeBase || !pageContentId) return null;
+  const url = new URL("/ru-RU/pagemanagement/pages", preset.backofficeBase);
+  url.searchParams.set("pageContentId", pageContentId);
+  return String(url);
+}
+
 export async function planDeployment({
   config,
   preset,
@@ -135,58 +197,94 @@ export async function deployProject({
   root = process.cwd(),
   token,
   client,
-  update = false,
-  relink = false,
-  pruneAssets = false,
-  publish = false,
   prompts,
   section,
   strategy = "ask",
   log = console.log,
+  ui,
 }) {
   const manifest = readBuildManifest(root);
   const api = client || new BackofficeClient({brand: preset.id, token});
   const previous = readDeploymentState(preset.id, manifest.folder, root);
-  log(`[deploy] target: ${preset.assetsBase}/${manifest.assetsPrefix}/`);
-  log(previous.placement && !relink
-    ? "[deploy] validating saved CMS placement..."
-    : relink ? "[deploy] selecting an existing CMS page..." : "[deploy] a new CMS page will be created");
+  const binding = readDeploymentBinding(preset.id, manifest.folder, root);
+  if (section && !manifest.blocks.some((block) => block.path === `${section}.html`)) {
+    const available = manifest.blocks.map((block) => block.path.replace(/\.html$/, ""));
+    throw new Error(`Section ${JSON.stringify(section)} not found. Available sections: ${available.join(", ") || "none"}`);
+  }
+  if (!ui) {
+    if (prompts) {
+      ui = {
+        ...prompts,
+        start() {},
+        plan() {},
+        confirmApply: prompts.confirmApply || (async () => true),
+        confirmPublish: prompts.confirmPublish || (async () => false),
+        info: (message) => log(`[deploy] ${message}`),
+        complete() {},
+      };
+    } else ui = await terminalDeployUi();
+  }
+  ui.start();
+  ui.info(`Checking ${manifest.assets.length} CDN asset${manifest.assets.length === 1 ? "" : "s"}`);
+  const missingAssets = await findMissingRemoteAssets({
+    manifest,
+    remoteRoot: new URL(preset.assetsBase).pathname,
+    listFiles: api.listFiles.bind(api),
+  });
+  if (missingAssets.length) {
+    throw new Error(
+      `Deploy stopped: ${missingAssets.length} asset${missingAssets.length === 1 ? " is" : "s are"} missing on CDN: ` +
+      `${missingAssets.join(", ")}. Run b2c-landing-vite deploy assets first.`
+    );
+  }
+
   let selectedPage = null;
+  let selectedDraft = null;
+  let nextBinding = binding;
   let remoteBefore = null;
-  if (relink) selectedPage = await selectExistingPagePlacement({client: api, domain: preset.domain, prompts});
-  else if (previous.placement) {
-    selectedPage = {
-      placement: previous.placement,
-      pageContent: await validateSavedPlacement({client: api, placement: previous.placement}),
-    };
+  if (binding) {
+    try {
+      selectedPage = await selectBoundPagePlacement({client: api, binding, prompts: ui});
+      nextBinding = selectedPage.binding;
+    } catch (error) {
+      const stale = error.code === "NOT_FOUND" || error.status === 404 ||
+        /no versions|missing CMS page|area that no longer exists/i.test(error.message);
+      if (!stale) throw error;
+      ui.info("Saved CMS binding is no longer valid; select a page again");
+      nextBinding = null;
+    }
   }
-  const availableSections = manifest.blocks.map((block) => block.path.replace(/\.html$/, ""));
-  if (section && !availableSections.includes(section)) {
-    throw new Error(`Section ${JSON.stringify(section)} not found. Available sections: ${availableSections.join(", ") || "none"}`);
+  if (!selectedPage) {
+    const mode = await ui.select({
+      message: "CMS page",
+      initialValue: "create",
+      options: [
+        {label: "Create a new CMS page", value: "create"},
+        {label: "Use an existing CMS page", value: "existing"},
+      ],
+    });
+    if (mode === "existing") {
+      selectedPage = await selectExistingPagePlacement({client: api, domain: preset.domain, prompts: ui});
+      nextBinding = selectedPage.binding;
+    } else {
+      selectedDraft = await selectNewPagePlacement({client: api, manifest, prompts: ui});
+    }
   }
+
   let reconciliation = null;
   if (selectedPage) {
-    log(`[deploy] scope: ${section ? `section ${JSON.stringify(section)}` : "page"}`);
     const local = localSections(manifest, root);
     const remote = remoteSections(selectedPage.pageContent, selectedPage.placement, manifest.folder);
     remoteBefore = remote;
     const base = previous.cms?.sections || null;
     let chosen = strategy;
-    reconciliation = resolveSections({local, remote, base, scope: section ? [section] : undefined, strategy: chosen === "ask" ? "merge" : chosen});
+      reconciliation = resolveSections({local, remote, base, scope: section ? [section] : undefined, strategy: chosen === "ask" ? "merge" : chosen});
     if (reconciliation.changes.length) {
       const summary = summarizeChanges(reconciliation.changes);
-      for (const [kind, ids] of Object.entries(summary)) if (ids.length) log(`[deploy] ${kind}: ${ids.join(", ")}`);
+      for (const [kind, ids] of Object.entries(summary)) if (ids.length) ui.info(`${kind}: ${ids.join(", ")}`);
     }
     if (reconciliation.unsafe.length && chosen === "ask") {
-      prompts ||= await (async () => {
-        const {isCancel, select} = await import("@clack/prompts");
-        return {select: async (options) => {
-          const value = await select(options);
-          if (isCancel(value)) throw new Error("Deploy cancelled");
-          return value;
-        }};
-      })();
-      chosen = await prompts.select({
+      chosen = await ui.select({
         message: "Remote CMS changes detected",
         options: [
           {label: "Keep remote changes", value: "remote"},
@@ -197,9 +295,22 @@ export async function deployProject({
       if (chosen === "cancel") throw new Error("Deploy cancelled; CMS was not modified");
       reconciliation = resolveSections({local, remote, base, scope: section ? [section] : undefined, strategy: chosen});
     } else if (reconciliation.unsafe.length) {
-      throw new Error(`Deploy stopped: remote changes require --force or --remote (${reconciliation.unsafe.map((item) => item.id).join(", ")})`);
+      throw new Error(`Deploy stopped: unresolved remote changes (${reconciliation.unsafe.map((item) => item.id).join(", ")})`);
     }
   }
+
+  const placement = selectedPage?.placement || selectedDraft.placement;
+  const pageContent = selectedPage?.pageContent || {pageContents: []};
+  const widgetPlan = scopedWidgetPlan(planWidgetChanges({manifest, placement, pageContent, root}), section);
+  ui.plan({
+    page: nextBinding?.pageId || selectedDraft.draft.pageName,
+    version: selectedPage ? versionLabel(selectedPage.pageContent) : "New page",
+    ...widgetPlan,
+    reorder: widgetPlan.reorder.map((item) => `${item.title} (${item.from} → ${item.to})`),
+    section,
+  });
+  if (!await ui.confirmApply()) throw new Error("Deploy cancelled; CMS was not modified");
+
   // No remote mutation happens until the page state and the user's resolution are known.
   if (selectedPage) {
     const verified = await validateSavedPlacement({client: api, placement: selectedPage.placement});
@@ -207,63 +318,75 @@ export async function deployProject({
       throw new Error("CMS page changed during deploy. Nothing was modified; run deploy again.");
     }
   }
-  log("[deploy] synchronizing CDN assets...");
-  const assets = await uploadChangedAssets({
-    manifest,
-    state: previous,
-    root,
-    remoteRoot: new URL(preset.assetsBase).pathname,
-    uploadFile: api.uploadFile.bind(api),
-    listFiles: api.listFiles?.bind(api),
-    prune: pruneAssets,
-    deleteFile: api.deleteFile?.bind(api),
-  });
   const page = selectedPage
-    ? await prepareExistingPage({client: api, placement: selectedPage.placement, update})
-    : await createPagePlacement({client: api, manifest, prompts});
+    ? await prepareExistingPage({client: api, placement: selectedPage.placement})
+    : await createPagePlacement({client: api, manifest, prompts: ui, selected: selectedDraft});
+  nextBinding = {...(page.binding || nextBinding), lastPageContentId: page.placement.pageContentId};
   if (selectedPage && page.placement.pageContentId === selectedPage.placement.pageContentId &&
     pageRevision(page.pageContent) !== pageRevision(selectedPage.pageContent)) {
     throw new Error("CMS page changed during deploy. No widgets were modified; run deploy again.");
   }
+  let sectionIds = null;
+  if (section) {
+    sectionIds = reconciliation?.sections?.[section] === remoteBefore?.[section] ? [] : [section];
+  } else if (reconciliation) {
+    sectionIds = [...new Set([
+      ...Object.keys(remoteBefore || {}),
+      ...Object.keys(reconciliation.sections || {}),
+    ])].filter((id) => reconciliation.sections?.[id] !== remoteBefore?.[id]);
+  }
   const widgets = await syncWidgets({
     client: api,
     manifest,
     placement: page.placement,
     pageContent: page.pageContent,
     root,
-    sectionIds: reconciliation ? [...new Set([
-      ...Object.keys(remoteBefore || {}),
-      ...Object.keys(reconciliation.sections || {}),
-    ])].filter((id) => reconciliation.sections?.[id] !== remoteBefore?.[id]) : null,
+    sectionIds,
   });
+  const verifiedContent = await api.getContent(page.placement.pageContentId);
+  const remoteAfter = remoteSections(verifiedContent, page.placement, manifest.folder);
+  const storedSections = section ? {...(previous.cms?.sections || {})} : remoteAfter;
+  if (section) {
+    if (remoteAfter[section] === undefined) delete storedSections[section];
+    else storedSections[section] = remoteAfter[section];
+  }
   const state = {
-    ...assets.state,
-    placement: page.placement,
+    ...previous,
     cms: {
       verifiedAt: new Date().toISOString(),
-      sections: remoteSections(await api.getContent(page.placement.pageContentId), page.placement, manifest.folder),
+      sections: storedSections,
     },
   };
+  writeDeploymentState(preset.id, manifest.folder, state, root);
+  writeDeploymentBinding(preset.id, manifest.folder, nextBinding, root);
+
+  let finalPageContent = verifiedContent;
   let published = false;
-  let finalPageContent = await api.getContent(page.placement.pageContentId);
-  if (publish) {
-    log("[deploy] validating CMS metadata and publishing...");
-    await publishPage({client: api, pageContent: finalPageContent});
-    published = true;
-    finalPageContent = await api.getContent(page.placement.pageContentId);
+  if (await ui.confirmPublish()) {
+    const issues = publicationIssues(finalPageContent);
+    if (issues.length) {
+      ui.info(`Publication blocked; fill in ${issues.join(", ")} in Backoffice`);
+    } else {
+      await publishPage({client: api, pageContent: finalPageContent});
+      published = true;
+      finalPageContent = await api.getContent(page.placement.pageContentId);
+    }
   }
-  writeDeploymentState(preset.id, manifest.folder, state, root);
   const preview = finalPageContent.uniqueId
     ? `https://${preset.domain}/preview/${finalPageContent.uniqueId}/`
     : null;
   const ru = finalPageContent.pageContents?.find((content) => String(content.languageId) === "1049");
   const live = published && ru?.perma ? `https://${preset.domain}/${ru.perma.replace(/^\/+/, "")}` : null;
-  log(`[deploy] assets: uploaded=${assets.uploaded.length}, skipped=${assets.skipped.length}, removed=${assets.removed.length}, unchanged=${assets.unchanged}`);
-  if (assets.skipped.length) {
-    log(`[deploy] existing assets were not overwritten: ${assets.skipped.join(", ")}. Rename changed files to publish new URLs.`);
-  }
-  log(`[deploy] widgets: added=${widgets.added}, updated=${widgets.updated}, removed=${widgets.removed}`);
-  if (preview) log(`[deploy] preview: ${preview}`);
-  if (live) log(`[deploy] live: ${live}`);
-  return {assets, widgets, placement: page.placement, preview, live, published};
+  const backoffice = backofficePageUrl(preset, page.placement.pageContentId);
+  ui.complete({widgets, preview, backoffice, live});
+  return {
+    assets: {verified: manifest.assets.length, missing: []},
+    widgets,
+    binding: nextBinding,
+    placement: page.placement,
+    preview,
+    backoffice,
+    live,
+    published,
+  };
 }

package/src/deploy/page.mjs

@@ -47,12 +47,35 @@ function pageLabel(page, domain) {
   return `${page.pageTitle || page.name || page.pageId} — ${link}`;
 }
 
-function versionLabel(content) {
+export function versionLabel(content) {
   const details = [content.statusName, content.version != null ? `v${content.version}` : null, content.author]
     .filter(Boolean).join(", ");
   return `${details || content.pageContentId}${content.modifiedTime ? ` — ${content.modifiedTime}` : ""}`;
 }
 
+function contentId(content) {
+  return content.pageContentId || content.contentId || content._id;
+}
+
+function isPublishedVersion(content) {
+  return Number(content.statusId ?? content.status) === STATUS.published ||
+    String(content.statusName || "").toLowerCase() === "published";
+}
+
+export async function selectPageVersion({client, pageId, versions, prompts}) {
+  prompts ||= await defaultPrompts();
+  versions ||= await client.getContentVersions(pageId);
+  if (!versions?.length) throw new Error("The selected CMS page has no versions");
+  if (versions.length === 1) return client.getContent(contentId(versions[0]));
+  const published = versions.find(isPublishedVersion);
+  const pageContentId = await prompts.select({
+    message: "Source page version",
+    initialValue: contentId(published || versions[0]),
+    options: versions.map((content) => ({label: versionLabel(content), value: contentId(content)})),
+  });
+  return client.getContent(pageContentId);
+}
+
 async function defaultPrompts() {
   const {isCancel, select, text} = await import("@clack/prompts");
   const answer = async (promise) => {
@@ -148,13 +171,13 @@ export async function selectExistingPagePlacement({client, domain, prompts}) {
     options: pages.map((page) => ({label: pageLabel(page, domain), value: page.pageId || page.id, page})),
   });
   const page = pages.find((candidate) => (candidate.pageId || candidate.id) === pageId);
-  const versions = page.contents?.length ? page.contents : await client.getContentVersions(pageId);
-  if (!versions?.length) throw new Error("The selected CMS page has no versions");
-  const pageContentId = await prompts.select({
-    message: "Page version",
-    options: versions.map((content) => ({label: versionLabel(content), value: content.pageContentId || content.contentId})),
+  const pageContent = await selectPageVersion({
+    client,
+    pageId,
+    versions: page.contents?.length ? page.contents : undefined,
+    prompts,
   });
-  const pageContent = await client.getContent(pageContentId);
+  const pageContentId = contentId(pageContent);
   const areas = suitableAreas(pageContent.layout?.schema || []);
   if (!areas.length) throw new Error("The selected page layout has no HTML widget area");
   const widgets = pageWidgets(pageContent);
@@ -176,11 +199,15 @@ export async function selectExistingPagePlacement({client, domain, prompts}) {
       value: index,
     })),
   });
-  return {pageContent, placement: {pageContentId, layoutAreaId, orderIndex}};
+  return {
+    pageContent,
+    placement: {pageContentId, layoutAreaId, orderIndex},
+    binding: {pageId, applicationId, layoutAreaId, orderIndex, lastPageContentId: pageContentId},
+  };
 }
 
 export async function createPagePlacement(options) {
-  const selected = await selectNewPagePlacement(options);
+  const selected = options.selected || await selectNewPagePlacement(options);
   const {client} = options;
   const created = await client.createPage({
     applicationId: selected.draft.applicationId,
@@ -188,9 +215,19 @@ export async function createPagePlacement(options) {
     name: selected.draft.pageName,
   });
   if (!created?.pageContentId) throw new Error("Backoffice did not return pageContentId for the new page");
+  const pageContent = await client.getContent(created.pageContentId);
+  const pageId = created.pageId || pageContent.pageId;
+  if (!pageId) throw new Error("Backoffice did not return pageId for the new page");
   return {
-    pageContent: await client.getContent(created.pageContentId),
+    pageContent,
     placement: {...selected.placement, pageContentId: created.pageContentId},
+    binding: {
+      pageId,
+      applicationId: selected.draft.applicationId,
+      layoutAreaId: selected.placement.layoutAreaId,
+      orderIndex: selected.placement.orderIndex,
+      lastPageContentId: created.pageContentId,
+    },
   };
 }
 
@@ -234,18 +271,29 @@ export async function validateSavedPlacement({client, placement}) {
     pageContent = await client.getContent(placement.pageContentId);
   } catch (error) {
     if (error.code === "NOT_FOUND" || error.status === 404) {
-      throw new Error("Saved deploy-state points to a missing CMS page version. Run deploy --relink.", {cause: error});
+      throw new Error("Saved deploy-state points to a missing CMS page version.", {cause: error});
     }
     throw error;
   }
   const schema = pageContent.layout?.schema;
   if (Array.isArray(schema) && !schema.flatMap((row) => row.children || [])
     .some((area) => (area.layoutAreaId || area.id) === placement.layoutAreaId)) {
-    throw new Error("Saved deploy-state points to an HTML area that no longer exists. Run deploy --relink.");
+    throw new Error("Saved deploy-state points to an HTML area that no longer exists.");
   }
   return pageContent;
 }
 
+export async function selectBoundPagePlacement({client, binding, prompts}) {
+  const pageContent = await selectPageVersion({client, pageId: binding.pageId, prompts});
+  const placement = {
+    pageContentId: contentId(pageContent),
+    layoutAreaId: binding.layoutAreaId,
+    orderIndex: binding.orderIndex,
+  };
+  await validateSavedPlacement({client, placement});
+  return {pageContent, placement, binding: {...binding, lastPageContentId: placement.pageContentId}};
+}
+
 export function pageRevision(pageContent) {
   return JSON.stringify({
     id: pageContent._id || pageContent.pageContentId,

package/src/deploy/state.mjs

@@ -2,13 +2,20 @@ import fs from "node:fs";
 import path from "node:path";
 
 const STATE_VERSION = 1;
+const BINDING_VERSION = 1;
 
 export function deploymentStatePath(site, folder, root = process.cwd()) {
-  return path.join(root, ".b2c", "deploy", `${site}--${folder}.json`);
+  return path.join(root, ".b2c", "deploy", `${site}--${folder}.state.json`);
+}
+
+export function deploymentBindingPath(site, folder, root = process.cwd()) {
+  return path.join(root, ".b2c", "deploy", `${site}--${folder}.binding.json`);
 }
 
 export function readDeploymentState(site, folder, root = process.cwd()) {
-  const filePath = deploymentStatePath(site, folder, root);
+  let filePath = deploymentStatePath(site, folder, root);
+  const legacyPath = path.join(root, ".b2c", "deploy", `${site}--${folder}.json`);
+  if (!fs.existsSync(filePath) && fs.existsSync(legacyPath)) filePath = legacyPath;
   if (!fs.existsSync(filePath)) return {schemaVersion: STATE_VERSION, assets: {}};
   const state = JSON.parse(fs.readFileSync(filePath, "utf8"));
   if (state.schemaVersion !== STATE_VERSION || !state.assets || typeof state.assets !== "object") {
@@ -17,6 +24,26 @@ export function readDeploymentState(site, folder, root = process.cwd()) {
   return state;
 }
 
+export function readDeploymentBinding(site, folder, root = process.cwd()) {
+  const filePath = deploymentBindingPath(site, folder, root);
+  if (!fs.existsSync(filePath)) return null;
+  const binding = JSON.parse(fs.readFileSync(filePath, "utf8"));
+  if (binding.schemaVersion !== BINDING_VERSION || !binding.pageId || !binding.layoutAreaId) {
+    throw new Error(`Invalid deployment binding: ${filePath}`);
+  }
+  return binding;
+}
+
+export function writeDeploymentBinding(site, folder, binding, root = process.cwd()) {
+  const filePath = deploymentBindingPath(site, folder, root);
+  fs.mkdirSync(path.dirname(filePath), {recursive: true});
+  const temporaryPath = `${filePath}.${process.pid}.tmp`;
+  const next = {...binding, schemaVersion: BINDING_VERSION};
+  fs.writeFileSync(temporaryPath, `${JSON.stringify(next, null, 2)}\n`);
+  fs.renameSync(temporaryPath, filePath);
+  return next;
+}
+
 export function writeDeploymentState(site, folder, state, root = process.cwd()) {
   const filePath = deploymentStatePath(site, folder, root);
   fs.mkdirSync(path.dirname(filePath), {recursive: true});

package/src/presets/coral.mjs

@@ -2,4 +2,5 @@ export default {
   id: "coral",
   domain: "www.coral.ru",
   assetsBase: "https://b2ccdn.coral.ru/content",
+  backofficeBase: "https://backoffice.coral.ru",
 };

package/src/presets/sunmar.mjs

@@ -2,4 +2,5 @@ export default {
   id: "sunmar",
   domain: "www.sunmar.ru",
   assetsBase: "https://b2ccdn.sunmar.ru/content",
+  backofficeBase: "https://backoffice.sunmar.ru",
 };

package/src/update/check-update.mjs

@@ -6,6 +6,7 @@ const packageJson = JSON.parse(
 
 export const CURRENT_VERSION = packageJson.version;
 export const PACKAGE_NAME = packageJson.name;
+export const TEMPLATE_PACKAGE_NAME = "@coraltravelcenter/create-b2c-landing-vite";
 
 function parseVersion(version) {
   const match = /^(\d+)\.(\d+)\.(\d+)(?:-([0-9A-Za-z.-]+))?$/.exec(version || "");
@@ -32,11 +33,12 @@ export function compareVersions(left, right) {
 export async function checkForUpdate({
   fetchImpl = globalThis.fetch,
   currentVersion = CURRENT_VERSION,
+  packageName = PACKAGE_NAME,
   timeoutMs = 3000,
 } = {}) {
   if (typeof fetchImpl !== "function") throw new Error("Fetch API is unavailable");
   const response = await fetchImpl(
-    `https://registry.npmjs.org/${encodeURIComponent(PACKAGE_NAME)}/latest`,
+    `https://registry.npmjs.org/${encodeURIComponent(packageName)}/latest`,
     {headers: {accept: "application/json"}, signal: AbortSignal.timeout(timeoutMs)}
   );
   if (!response.ok) throw new Error(`npm registry responded with HTTP ${response.status}`);
@@ -49,6 +51,15 @@ export async function checkForUpdate({
   };
 }
 
+export async function checkTemplateUpdate({templateVersion, ...options} = {}) {
+  const status = await checkForUpdate({
+    ...options,
+    packageName: TEMPLATE_PACKAGE_NAME,
+    currentVersion: templateVersion || "0.0.0",
+  });
+  return {...status, legacy: !templateVersion};
+}
+
 export async function printUpdateStatus(options) {
   try {
     const status = await checkForUpdate(options);
@@ -65,15 +76,28 @@ export async function printUpdateStatus(options) {
   }
 }
 
-export async function printUpdateNotice({log = console.warn, timeoutMs = 1000, ...options} = {}) {
-  try {
-    const status = await checkForUpdate({...options, timeoutMs});
-    if (!status.updateAvailable) return status;
+export async function printUpdateNotice({
+  log = console.warn,
+  timeoutMs = 1000,
+  templateVersion,
+  ...options
+} = {}) {
+  const [builder, template] = await Promise.all([
+    checkForUpdate({...options, timeoutMs}).catch(() => null),
+    checkTemplateUpdate({...options, timeoutMs, templateVersion}).catch(() => null),
+  ]);
+  const builderUpdate = builder?.updateAvailable;
+  const templateUpdate = template?.updateAvailable;
+  if (!builderUpdate && !templateUpdate) return {builder, template};
 
-    log(`New ${PACKAGE_NAME} version available: ${status.currentVersion} → ${status.latestVersion}`);
-    log(`Update manually: npm install --global ${PACKAGE_NAME}@latest`);
-    return status;
-  } catch {
-    return null;
+  log("Updates available:");
+  if (builderUpdate) {
+    log(`Builder: ${builder.currentVersion} → ${builder.latestVersion}`);
+    log(`npm install --global ${PACKAGE_NAME}@latest`);
+  }
+  if (templateUpdate) {
+    log(`Project template: ${template.legacy ? "legacy" : template.currentVersion} → ${template.latestVersion}`);
+    log(`npx ${TEMPLATE_PACKAGE_NAME}@latest migrate`);
   }
+  return {builder, template};
 }

package/src/vite/client.js

@@ -30,6 +30,9 @@ function waitForContainer() {
   });
 }
 
-const container = await waitForContainer();
-mount(container, parts);
-setupLocalCdnAssetRewrite({root: container, cdnBase: "http://127.0.0.1:5173"});
+if (window.location.hostname === __B2C_TARGET_HOST__) {
+  const container = await waitForContainer();
+  mount(container, parts);
+  const devOrigin = new URL("/", import.meta.url).origin;
+  setupLocalCdnAssetRewrite({root: container, cdnBase: devOrigin});
+}

package/src/vite/config.mjs

@@ -18,6 +18,18 @@ export function toViteFsUrl(filePath) {
 const clientEntryUrl = toViteFsUrl(clientEntry);
 let monkeyPlugin;
 
+export function resolveDevServerPort(env = process.env) {
+  const explicitPort = env.B2C_PORT;
+  if (explicitPort === undefined || explicitPort === "") {
+    return {port: 5173, strictPort: false};
+  }
+  const port = Number(explicitPort);
+  if (!Number.isInteger(port) || port < 1 || port > 65535) {
+    throw new Error("B2C_PORT must be an integer between 1 and 65535");
+  }
+  return {port, strictPort: true};
+}
+
 async function loadMonkeyPlugin() {
   if (monkeyPlugin) return monkeyPlugin;
 
@@ -36,6 +48,7 @@ export async function createViteConfig(root = process.cwd()) {
   const preset = resolvePreset(config.site.preset);
   const monkey = await loadMonkeyPlugin();
   const shouldOpen = process.env.B2C_NO_OPEN !== "1";
+  const devPort = resolveDevServerPort();
   const vue = resolveScriptStack(config.stack.script).vue
     ? await loadProjectVuePlugin(root)
     : null;
@@ -45,8 +58,7 @@ export async function createViteConfig(root = process.cwd()) {
     configFile: false,
     server: {
       host: "127.0.0.1",
-      port: Number(process.env.B2C_PORT || 5173),
-      strictPort: true,
+      ...devPort,
       cors: true,
       open: shouldOpen ? "/__vite-plugin-monkey.install.user.js" : false,
       fs: {allow: [root, builderRoot]},
@@ -59,13 +71,16 @@ export async function createViteConfig(root = process.cwd()) {
         server: {open: shouldOpen, prefix: false},
         userscript: {
           name: config.project.name,
-          namespace: "b2c-landing-builder",
+          namespace: `b2c-landing-builder:${preset.id}`,
           match: [`https://${preset.domain}/monkey/*`],
           grant: "none",
           "run-at": "document-idle",
         },
       }),
     ].filter(Boolean),
+    define: {
+      __B2C_TARGET_HOST__: JSON.stringify(preset.domain),
+    },
   };
 }