at-builder 1.2.9 → 1.4.0

package/lib/at-deploy.js

@@ -4,47 +4,59 @@
 /*
  * Adobe Target Build Deploy Script
  * --------------------------------
- * This script automates the deployment of build assets to an Adobe Target activity.
+ * Automates deployment of build assets to an Adobe Target activity.
  *
  * Features:
- * - Reads build config and allowed variations from build.config.json in the build folder.
- * - Dynamically finds and injects built HTML assets for each experience/variation.
- * - Updates only the allowed experiences in Adobe Target.
- * - Provides color-coded logs and a summary of what was updated, skipped, or unchanged.
- * - Can be run in verbose mode to show more details (use -v or --verbose).
+ * - Reads activity id/type/variations from build.config.json (single-page or multi-page).
+ * - Supports AB and XT activity types.
+ * - Discovers built HTML assets and injects them into the AT activity payload.
+ * - Updates only allowed experiences; creates new options when slots are empty.
+ * - Prunes orphan options and deduplicates options with identical offerContent
+ *   (avoids AT's UniqueElements.ABActivity.options rejection on multi-page deploys).
+ * - --dry-run    : preview the resulting payload without PUTting.
+ * - --force      : override the 60s cooldown lock between deploys.
+ * - -v|--verbose : reserved for future use; kept for parity.
  *
- * Usage:
- *   node at-deploy.js [-v|--verbose]
+ * Usage (via CLI):
+ *   atb deploy [--dry-run] [--force]
  *
- * Environment variables required:
- *   ACTIVITY_FOLDER_NAME, ADOBE_CLIENT_ID, ADOBE_CLIENT_SECRET
- *   (and .env file for any secrets)
+ * Usage (direct, when developing at-builder itself):
+ *   node lib/at-deploy.js [--dry-run] [--force]
  *
- * Example:
- *   ACTIVITY_FOLDER_NAME="UPSDDO-XXXX" \
- *   ADOBE_CLIENT_ID=... ADOBE_CLIENT_SECRET=... node at-deploy.js -v
+ * Path resolution:
+ *   at-builder is a globally-installed CLI. Every consumer file resolves against
+ *   PWD = process.env.executionPath || process.cwd() so that the user's project
+ *   directory is the source of truth, not at-builder's install location.
+ *
+ * Environment variables (consumer's .env):
+ *   ACTIVITY_FOLDER_NAME      (required)
+ *   ACTIVITIES_BASE_FOLDER    (optional, defaults to "Activities")
+ *   ADOBE_CLIENT_ID           (required)
+ *   ADOBE_CLIENT_SECRET       (required)
+ *   ADOBE_TENANT              (optional, your AT tenant slug — enables clickable AT UI link)
  *
- * Maintainers: Update build.config.json and build output structure as needed for new activities.
- * 
  * Author: Upendra Sengar
- * Date: 2024-03-12
  */
 
 /* eslint-env node */
 const path = require('path');
-
 const dotenv = require('dotenv');
 
 const PWD = process.env.executionPath || process.cwd();
+dotenv.config({ path: path.join(PWD, '.env'), quiet: true });
 
-dotenv.config({ path: path.join(PWD, ".env"), quiet: true });
-
-const { execSync } = require('child_process');
+const { execFileSync } = require('child_process');
 const axios = require('axios');
 const qs = require('querystring');
 const fs = require('fs');
 
 const { BASE_URL, IMS_TOKEN_URL, IMS_SCOPE } = require(path.join(PWD, 'adobe.config'));
+
+const VALID_ACTIVITY_TYPES = ['ab', 'xt'];
+const OFFER_TEMPLATE_ID = 133;
+const COOLDOWN_SECONDS = 60;
+const DEPLOY_LOCK_FILE = path.join(PWD, '.deploy-lock');
+
 // Fallback to ANSI codes since chalk 5.x is ESM only
 const chalk = {
     green: (s) => `\x1b[32m${s}\x1b[0m`,
@@ -54,95 +66,146 @@ const chalk = {
     bold: (s) => `\x1b[1m${s}\x1b[0m`
 };
 
-// Validate required environment variables
+// CLI flags
+const args = process.argv.slice(2);
+const DRY_RUN = args.includes('--dry-run');
+const FORCE = args.includes('--force');
+
+// ─── Validate env ───
 if (!process.env.ACTIVITY_FOLDER_NAME || process.env.ACTIVITY_FOLDER_NAME.trim() === '') {
     console.error(chalk.red('❌ Error: ACTIVITY_FOLDER_NAME environment variable is required but not set.'));
-    console.error(chalk.yellow('💡 Please set ACTIVITY_FOLDER_NAME in your .env file or run "atb doctor --fix" to check your configuration.'));
+    console.error(chalk.yellow('💡 Set ACTIVITY_FOLDER_NAME in your .env file or run "atb doctor --fix".'));
     process.exit(1);
 }
-
-// Build root directory for variations, using same approach as webpack config
-const ACTIVITIES_BASE_FOLDER = process.env.ACTIVITIES_BASE_FOLDER || 'Activities';
-const ACTIVITY_FOLDER = process.env.ACTIVITY_FOLDER_NAME.trim();
-const BUILD_ROOT = path.join(PWD, ACTIVITIES_BASE_FOLDER, ACTIVITY_FOLDER).toString();
-
-// Validate Adobe credentials
 if (!process.env.ADOBE_CLIENT_ID || process.env.ADOBE_CLIENT_ID.trim() === '') {
     console.error(chalk.red('❌ Error: ADOBE_CLIENT_ID environment variable is required but not set.'));
-    console.error(chalk.yellow('💡 Please set your Adobe Target API credentials in your .env file.'));
+    console.error(chalk.yellow('💡 Set your Adobe Target API credentials in your .env file.'));
     process.exit(1);
 }
-
 if (!process.env.ADOBE_CLIENT_SECRET || process.env.ADOBE_CLIENT_SECRET.trim() === '') {
     console.error(chalk.red('❌ Error: ADOBE_CLIENT_SECRET environment variable is required but not set.'));
-    console.error(chalk.yellow('💡 Please set your Adobe Target API credentials in your .env file.'));
+    console.error(chalk.yellow('💡 Set your Adobe Target API credentials in your .env file.'));
     process.exit(1);
 }
 
+const ACTIVITIES_BASE_FOLDER = process.env.ACTIVITIES_BASE_FOLDER || 'Activities';
+const ACTIVITY_FOLDER = process.env.ACTIVITY_FOLDER_NAME.trim();
+const BUILD_ROOT = path.join(PWD, ACTIVITIES_BASE_FOLDER, ACTIVITY_FOLDER).toString();
+
 console.log(chalk.cyan(`📦 Deploying activity: ${ACTIVITY_FOLDER}`));
 console.log(chalk.cyan(`📁 Activities folder: ${ACTIVITIES_BASE_FOLDER}`));
 
-// Utility: normalize experience name from folder name
+// ─── Helpers ───
+
+// Normalize experience name from folder name: lowercase + spaces→hyphens.
+// Matches the convention used by at-sync.js.
 function normalizeExperienceName(folder) {
     if (!folder) return '';
-    const name = folder.toLowerCase();
-    if (name === 'vcontrol') return 'control';
-    if (name.startsWith('variation-')) return 'variation ' + name.split('-')[1];
-    return name;
+    return folder.toLowerCase().replace(/\s+/g, '-');
 }
 
-// Read build.config.json for activity id and allowed variations
+// Read build.config.json. Supports `shared/` and `Shared/` casing.
 function readBuildJson() {
-    const buildJsonPath = path.join(BUILD_ROOT, "shared", 'build.config.json');
-    if (!fs.existsSync(buildJsonPath)) {
-        throw new Error(`build.json not found at ${buildJsonPath}`);
+    const configPaths = [
+        path.join(BUILD_ROOT, 'shared', 'build.config.json'),
+        path.join(BUILD_ROOT, 'Shared', 'build.config.json')
+    ];
+    const buildJsonPath = configPaths.find(p => fs.existsSync(p));
+    if (!buildJsonPath) {
+        throw new Error(`build.config.json not found in ${BUILD_ROOT}/shared/`);
     }
     const buildJson = JSON.parse(fs.readFileSync(buildJsonPath, 'utf8'));
     const activityId = buildJson.activityInfo?.id;
-    if (activityId === null) {
+    if (!activityId) {
         throw new Error('Invalid build.config.json: missing activity id');
     }
-    console.log('buildJson.activityInfo?.variations', buildJson.activityInfo?.variations);
-    // To support older versions , keeping array checks
+    const activityType = (buildJson.activityInfo?.activityType || 'ab').toLowerCase();
+    if (!VALID_ACTIVITY_TYPES.includes(activityType)) {
+        throw new Error(`Invalid build.config.json: activityType must be one of ${VALID_ACTIVITY_TYPES.join(', ')}, got '${activityType}'`);
+    }
+
+    // Back-compat: array form → object form
     let allowedVariations = buildJson.activityInfo?.variations;
-    if (buildJson.activityInfo?.variations && Array.isArray(buildJson.activityInfo.variations)) {
-        // convert to object
-        allowedVariations = Object.fromEntries((buildJson.activityInfo?.variations || []).map(v => [v, v]));
+    if (Array.isArray(allowedVariations)) {
+        allowedVariations = Object.fromEntries(allowedVariations.map(v => [v, v]));
+    }
+    if (!allowedVariations || Object.keys(allowedVariations).length === 0) {
+        throw new Error('Invalid build.config.json: missing variations');
     }
 
-    console.log('allowedVariations', allowedVariations);
+    // Detect multi-page format: variation values are objects with { experienceName, pages }
+    const firstValue = Object.values(allowedVariations)[0];
+    const isMultiPage = typeof firstValue === 'object' && firstValue !== null && !!firstValue.pages;
 
-    if (!activityId || !allowedVariations || Object.keys(allowedVariations).length === 0) {
-        throw new Error('Invalid build.json: missing activity id or variations');
+    const pages = buildJson.activityInfo?.pages || null;
+    if (isMultiPage && !pages) {
+        throw new Error('Invalid build.config.json: multi-page variations require a "pages" map');
     }
-    const activityName = buildJson.activityInfo?.name.toLowerCase();
+
+    const activityName = buildJson.activityInfo?.name?.toLowerCase();
     if (!activityName) {
         throw new Error('Invalid build.config.json: missing activity name');
     }
-    return { activityId, allowedVariations, activityName };
+    return { activityId, activityType, allowedVariations, activityName, isMultiPage, pages };
 }
 
-// Dynamically discover build assets for each experience/variation
-function getBuildAssets() {
+// Discover build assets.
+//  Single-page: buildAssets[expKey] = html
+//  Multi-page:  buildAssets[expKey][pageSubfolder] = html
+function getBuildAssets(isMultiPage, allowedVariations) {
     const buildAssets = {};
     if (!fs.existsSync(BUILD_ROOT)) {
         console.error('Build root does not exist:', BUILD_ROOT);
         return buildAssets;
     }
     const subdirs = fs.readdirSync(BUILD_ROOT, { withFileTypes: true })
-        .filter(dirent => dirent.isDirectory());
-    for (const dirent of subdirs) {
-        const subdir = dirent.name;
-        const distPath = path.join(BUILD_ROOT, subdir, 'dist', 'at-build.html');
-        if (fs.existsSync(distPath)) {
-            const expName = normalizeExperienceName(subdir);
-            buildAssets[expName] = fs.readFileSync(distPath, 'utf8');
+        .filter(d => d.isDirectory() && !['shared', 'Shared', '.DS_Store'].includes(d.name));
+
+    if (isMultiPage) {
+        for (const dirent of subdirs) {
+            const expFolder = dirent.name;
+            const expKey = normalizeExperienceName(expFolder);
+            buildAssets[expKey] = {};
+            const expPath = path.join(BUILD_ROOT, expFolder);
+
+            const pageDirs = fs.readdirSync(expPath, { withFileTypes: true })
+                .filter(d => d.isDirectory() && d.name !== 'dist');
+            for (const pageDir of pageDirs) {
+                const assetPath = path.join(expPath, pageDir.name, 'dist', 'at-build.html');
+                if (fs.existsSync(assetPath)) {
+                    buildAssets[expKey][pageDir.name.toLowerCase()] = fs.readFileSync(assetPath, 'utf8');
+                }
+            }
+
+            // Fallback: flat dist/at-build.html reused for every page in the config
+            if (Object.keys(buildAssets[expKey]).length === 0) {
+                const flatAssetPath = path.join(expPath, 'dist', 'at-build.html');
+                if (fs.existsSync(flatAssetPath)) {
+                    const flatAsset = fs.readFileSync(flatAssetPath, 'utf8');
+                    const configKey = Object.keys(allowedVariations).find(k => k.toLowerCase() === expKey);
+                    const varConfig = configKey ? allowedVariations[configKey] : null;
+                    if (varConfig?.pages) {
+                        for (const pageFolder of Object.values(varConfig.pages)) {
+                            const leaf = pageFolder.split('/').pop().toLowerCase();
+                            buildAssets[expKey][leaf] = flatAsset;
+                        }
+                    }
+                }
+            }
+        }
+    } else {
+        for (const dirent of subdirs) {
+            const subdir = dirent.name;
+            const distPath = path.join(BUILD_ROOT, subdir, 'dist', 'at-build.html');
+            if (fs.existsSync(distPath)) {
+                const expKey = normalizeExperienceName(subdir);
+                buildAssets[expKey] = fs.readFileSync(distPath, 'utf8');
+            }
         }
     }
     return buildAssets;
 }
 
-// Fetch Adobe OAuth token using client credentials
 async function fetchAdobeToken() {
     const data = qs.stringify({
         grant_type: 'client_credentials',
@@ -150,11 +213,10 @@ async function fetchAdobeToken() {
         client_secret: process.env.ADOBE_CLIENT_SECRET,
         scope: IMS_SCOPE
     });
-    const headers = {
-        'Content-Type': 'application/x-www-form-urlencoded'
-    };
     try {
-        const res = await axios.post(IMS_TOKEN_URL, data, { headers });
+        const res = await axios.post(IMS_TOKEN_URL, data, {
+            headers: { 'Content-Type': 'application/x-www-form-urlencoded' }
+        });
         return res.data.access_token;
     } catch (err) {
         console.error('Failed to fetch Adobe token:', err.response ? err.response.data : err.message);
@@ -162,26 +224,66 @@ async function fetchAdobeToken() {
     }
 }
 
-// 1. Run the build (calls your build system, e.g. webpack)
+// Build a clickable AT UI link if ADOBE_TENANT is set; otherwise return null.
+function buildAtUiLink(activityType, activityId) {
+    const tenant = (process.env.ADOBE_TENANT || '').trim();
+    if (!tenant) return null;
+    const slug = { ab: 'ab_manual', xt: 'experience_targeting' }[activityType] || activityType;
+    return `https://experience.adobe.com/#/@${tenant}/target/activities/activity-details/${slug}/${activityId}/overview`;
+}
+
+// ─── Cooldown lock ───
+if (!DRY_RUN && !FORCE && fs.existsSync(DEPLOY_LOCK_FILE)) {
+    const lastDeploy = parseInt(fs.readFileSync(DEPLOY_LOCK_FILE, 'utf8'), 10);
+    const elapsed = Math.floor((Date.now() - lastDeploy) / 1000);
+    if (Number.isFinite(elapsed) && elapsed < COOLDOWN_SECONDS) {
+        console.error(chalk.red(`⛔ Deploy blocked — last deploy was ${elapsed}s ago (cooldown: ${COOLDOWN_SECONDS}s)`));
+        console.error(chalk.yellow(`   Use --force to override, or wait ${COOLDOWN_SECONDS - elapsed}s.`));
+        process.exit(1);
+    }
+}
+
+if (DRY_RUN) {
+    console.log(chalk.bold(chalk.cyan('\n🔍 DRY RUN MODE — no changes will be deployed\n')));
+}
+
+// 1. Build (runs in at-builder install dir; webpack reads consumer files via executionPath)
+// stdio is inherited so webpack's per-error output (incl. ESLint file:line:col
+// messages) lands directly in the user's terminal. If the build fails we exit
+// cleanly with the child's exit code instead of letting execFileSync's throw
+// surface as an unhandled Node stack trace.
 console.log('Running build...');
-execSync('npm run atb:build:prod', { stdio: 'inherit' });
+try {
+    execFileSync('npm', ['run', 'atb:build:prod'], { stdio: 'inherit', shell: true });
+} catch (err) {
+    console.error(chalk.red('\n❌ Build failed. Fix the errors above and re-run "atb deploy".'));
+    process.exit(typeof err.status === 'number' ? err.status : 1);
+}
 
 (async () => {
     try {
-        // Read build config and allowed variations
-        const { activityId, allowedVariations, activityName } = readBuildJson();
-        let listOfAllowedVariations = [];
-
-        listOfAllowedVariations = Object.keys(allowedVariations).map(v => v.toLowerCase());
-
-        const allowedVariationReversedKey = Object.fromEntries(Object.entries(allowedVariations).map(([key, value]) => [value.toLowerCase(), key.toLowerCase()]));
+        const { activityId, activityType, allowedVariations, activityName, isMultiPage, pages } = readBuildJson();
+        const ACTIVITY_URL = `${BASE_URL}${activityType}/${activityId}`;
+        console.log(chalk.cyan(`Activity Type: ${activityType.toUpperCase()} | ID: ${activityId}${isMultiPage ? ' | Multi-Page' : ''}`));
+
+        // Reverse lookup: AT experience name → config folder key
+        const listOfAllowedVariations = Object.keys(allowedVariations).map(v => v.toLowerCase());
+        let allowedVariationReversedKey = {};
+        if (isMultiPage) {
+            for (const [folderKey, config] of Object.entries(allowedVariations)) {
+                allowedVariationReversedKey[config.experienceName.toLowerCase()] = folderKey.toLowerCase();
+            }
+        } else {
+            allowedVariationReversedKey = Object.fromEntries(
+                Object.entries(allowedVariations).map(([key, value]) => [value.toLowerCase(), key.toLowerCase()])
+            );
+        }
 
         const API_KEY = process.env.ADOBE_CLIENT_ID;
         const token = await fetchAdobeToken();
 
-        // 2. Fetch current Adobe Target activity
-        const getActivity = async (activityId) => {
-            const res = await axios.get(`${BASE_URL}${activityId}`, {
+        const getActivity = async () => {
+            const res = await axios.get(ACTIVITY_URL, {
                 headers: {
                     'X-Api-Key': API_KEY,
                     Accept: 'application/vnd.adobe.target.v3+json',
@@ -191,96 +293,165 @@ execSync('npm run atb:build:prod', { stdio: 'inherit' });
             return res.data;
         };
 
-        // 3. Update activity with new build info
-        const updateActivity = async (activity, activityId) => {
-            if (activity.state === "approved") {
-                /*
-                Status Mapping Logic for UI Display:
-
-                API State     | Start At       | End At         | UI Status
-                -------------------------------------------------------------
-                Approved      | in the past     | in the future   | Live
-                Approved      | in the past     | in the past     | Ended
-                Approved      | in the future   | in the future   | Scheduled
-                Saved         | -               | -               | Inactive
-                Deactivated   | -               | -               | Archived
-                Deleted       | -               | -               | Does Not Appear in the UI
-
-                Notes:
-                - "Start At" and "End At" are datetime values used to determine temporal status.
-                - For states with "-", time values are not evaluated.
-                - Items with "Deleted" status should be filtered out entirely from the UI.
-                */
-
+        const updateActivity = async (activity) => {
+            if (activity.state === 'approved') {
                 throw new Error("Live activity can't be updated");
             }
-            // Dynamically get build assets
-            const buildAssets = getBuildAssets();
-
-            // Prepare new payload (copy structure)
-            const newPayload = {
-                name: activity.name,
-                options: activity.options,
-                locations: activity.locations,
-                experiences: activity.experiences,
-                metrics: activity.metrics,
-                analytics: activity.analytics
-            };
+
+            const buildAssets = getBuildAssets(isMultiPage, allowedVariations);
+
+            // Deep copy so we can safely mutate options/optionLocations.
+            const newPayload = JSON.parse(JSON.stringify(activity));
 
             if (activityName !== activity.name.toLowerCase()) {
                 throw new Error('Activity name in build.config.json does not match activity name in Adobe Target');
             }
 
+            // Track next available optionLocalId for newly created options.
+            let nextOptionId = Math.max(...newPayload.options.map(o => o.optionLocalId)) + 1;
+
+            function createOption(asset, label) {
+                const newId = nextOptionId++;
+                newPayload.options.push({
+                    optionLocalId: newId,
+                    name: `Offer ${newId}`,
+                    offerId: 0,
+                    offerTemplates: [{
+                        offerTemplateId: OFFER_TEMPLATE_ID,
+                        templateParameters: [
+                            { name: 'uiData', value: JSON.stringify({ tagType: 'Code', actionType: 'added' }) },
+                            { name: 'offerContent', value: asset }
+                        ]
+                    }]
+                });
+                console.log(chalk.green(`  + Created new option[${newId}] for ${label}`));
+                return newId;
+            }
+
             const updatedExperiences = [];
             const skippedExperiences = [];
             const unchangedExperiences = [];
+            const createdOptions = [];
             let anyChange = false;
 
-            // For each experience, update only if in allowed variations and asset exists
             newPayload.experiences.forEach(exp => {
                 let expName = exp.name.trim().toLowerCase();
-                // Added to handle new type of build config
                 if (allowedVariationReversedKey) {
                     expName = allowedVariationReversedKey[expName] || expName;
                 }
-
                 if (!listOfAllowedVariations.includes(expName)) {
-                    skippedExperiences.push({ name: exp.name, reason: 'Not in allowed variations in build.config.json' });
+                    skippedExperiences.push({ name: exp.name, reason: 'Not in allowed variations' });
                     return;
                 }
 
+                expName = normalizeExperienceName(expName);
                 if (!buildAssets[expName]) {
                     skippedExperiences.push({ name: exp.name, reason: 'No build asset found' });
                     return;
                 }
+
                 let changed = false;
-                exp.optionLocations.forEach(ol => {
-                    const { optionLocalId } = ol;
-                    const option = newPayload.options.find(o => o.optionLocalId === optionLocalId);
-                    if (!option) return;
-                    option.offerTemplates.forEach(offerTemplate => {
-                        if (offerTemplate.offerTemplateId === 133) {
-                            offerTemplate.templateParameters.forEach(param => {
-                                if (param.name === 'offerContent') {
-                                    if (param.value !== buildAssets[expName]) {
-                                        param.value = buildAssets[expName];
+
+                if (isMultiPage) {
+                    const variationConfig = allowedVariations[
+                        Object.keys(allowedVariations).find(k => k.toLowerCase() === expName)
+                    ];
+                    const pageMap = variationConfig?.pages || {};
+
+                    const locationToPage = {};
+                    for (const [pageName, locId] of Object.entries(pages)) {
+                        locationToPage[locId] = pageName;
+                    }
+
+                    const claimedOptions = new Set();
+
+                    exp.optionLocations.forEach(ol => {
+                        const { locationLocalId, optionLocalId } = ol;
+                        const pageName = locationToPage[locationLocalId];
+                        if (!pageName) return;
+
+                        const assetSubPath = pageMap[pageName];
+                        if (!assetSubPath) return;
+
+                        const pageFolder = assetSubPath.split('/').pop().toLowerCase();
+                        const asset = buildAssets[expName]?.[pageFolder];
+                        if (!asset) {
+                            console.log(chalk.yellow(`  No asset for ${exp.name} → ${pageName} (${pageFolder})`));
+                            return;
+                        }
+
+                        if (optionLocalId === 0) {
+                            const newId = createOption(asset, `${exp.name} → ${pageName}`);
+                            ol.optionLocalId = newId;
+                            changed = true;
+                            anyChange = true;
+                            createdOptions.push(`${exp.name} → ${pageName}`);
+                            return;
+                        }
+
+                        if (claimedOptions.has(optionLocalId)) {
+                            const existingOption = newPayload.options.find(o => o.optionLocalId === optionLocalId);
+                            const existingContent = existingOption?.offerTemplates
+                                ?.find(t => t.offerTemplateId === OFFER_TEMPLATE_ID)
+                                ?.templateParameters?.find(p => p.name === 'offerContent')?.value;
+
+                            if (existingContent === asset) {
+                                console.log(chalk.green(`  ✓ ${exp.name} → ${pageName} (reused)`));
+                                return;
+                            }
+
+                            const newId = createOption(asset, `${exp.name} → ${pageName}`);
+                            ol.optionLocalId = newId;
+                            changed = true;
+                            anyChange = true;
+                            createdOptions.push(`${exp.name} → ${pageName}`);
+                            return;
+                        }
+
+                        claimedOptions.add(optionLocalId);
+                        const option = newPayload.options.find(o => o.optionLocalId === optionLocalId);
+                        if (!option) return;
+                        option.offerTemplates.forEach(ot => {
+                            if (ot.offerTemplateId === OFFER_TEMPLATE_ID) {
+                                ot.templateParameters.forEach(param => {
+                                    if (param.name === 'offerContent' && param.value !== asset) {
+                                        param.value = asset;
                                         changed = true;
                                         anyChange = true;
+                                        console.log(chalk.green(`  ✓ ${exp.name} → ${pageName}`));
                                     }
-                                }
-                            });
-                        }
+                                });
+                            }
+                        });
                     });
-                });
-                if (changed) {
-                    updatedExperiences.push(exp.name);
                 } else {
-                    unchangedExperiences.push(exp.name);
+                    exp.optionLocations.forEach(ol => {
+                        const { optionLocalId } = ol;
+                        const option = newPayload.options.find(o => o.optionLocalId === optionLocalId);
+                        if (!option) return;
+                        option.offerTemplates.forEach(ot => {
+                            if (ot.offerTemplateId === OFFER_TEMPLATE_ID) {
+                                ot.templateParameters.forEach(param => {
+                                    if (param.name === 'offerContent' && param.value !== buildAssets[expName]) {
+                                        param.value = buildAssets[expName];
+                                        changed = true;
+                                        anyChange = true;
+                                    }
+                                });
+                            }
+                        });
+                    });
                 }
+
+                if (changed) updatedExperiences.push(exp.name);
+                else unchangedExperiences.push(exp.name);
             });
 
-            // Logging summary
+            // ── Summary ──
             console.log(chalk.bold('--- Experience Update Summary ---'));
+            if (createdOptions.length > 0) {
+                console.log(chalk.green('Created new options:'), createdOptions.join(', '));
+            }
             if (updatedExperiences.length > 0) {
                 console.log(chalk.green('Updated experiences:'), updatedExperiences.join(', '));
             }
@@ -295,22 +466,85 @@ execSync('npm run atb:build:prod', { stdio: 'inherit' });
             if (!anyChange) {
                 console.log(chalk.cyan('No changes were made to any experience.'));
             } else {
-                // Uncomment to actually update Adobe Target
-                await axios.put(`${BASE_URL}${activityId}`, newPayload, {
-                    headers: {
-                        'X-Api-Key': API_KEY,
-                        'Content-Type': 'application/vnd.adobe.target.v3+json',
-                        Authorization: `Bearer ${token}`
-                    }
+                // Prune orphaned options (no longer referenced by any experience).
+                const referencedOptionIds = new Set();
+                newPayload.experiences.forEach(exp => {
+                    exp.optionLocations.forEach(ol => referencedOptionIds.add(ol.optionLocalId));
                 });
-                console.log('New build deployed!');
+                const beforeCount = newPayload.options.length;
+                newPayload.options = newPayload.options.filter(o => referencedOptionIds.has(o.optionLocalId));
+                const pruned = beforeCount - newPayload.options.length;
+                if (pruned > 0) {
+                    console.log(chalk.cyan(`Pruned ${pruned} orphaned option(s)`));
+                }
+
+                // Deduplicate options by offerContent. AT rejects PUTs with two
+                // options that have byte-identical offerContent (UniqueElements).
+                {
+                    const contentToSurvivorId = new Map();
+                    const duplicateIdToSurvivorId = new Map();
+
+                    newPayload.options.forEach(opt => {
+                        if (opt.optionLocalId === 0) return; // never merge Default Content
+                        const offerContent = opt.offerTemplates
+                            ?.find(t => t.offerTemplateId === OFFER_TEMPLATE_ID)
+                            ?.templateParameters?.find(p => p.name === 'offerContent')?.value;
+                        if (offerContent === undefined) return;
+
+                        if (!contentToSurvivorId.has(offerContent)) {
+                            contentToSurvivorId.set(offerContent, opt.optionLocalId);
+                        } else {
+                            duplicateIdToSurvivorId.set(opt.optionLocalId, contentToSurvivorId.get(offerContent));
+                        }
+                    });
+
+                    if (duplicateIdToSurvivorId.size > 0) {
+                        newPayload.experiences.forEach(exp => {
+                            exp.optionLocations.forEach(ol => {
+                                if (duplicateIdToSurvivorId.has(ol.optionLocalId)) {
+                                    ol.optionLocalId = duplicateIdToSurvivorId.get(ol.optionLocalId);
+                                }
+                            });
+                        });
+                        const duplicateIds = new Set(duplicateIdToSurvivorId.keys());
+                        newPayload.options = newPayload.options.filter(o => !duplicateIds.has(o.optionLocalId));
+                        console.log(chalk.cyan(`Deduplicated ${duplicateIds.size} option(s) with identical offerContent`));
+                    }
+                }
+
+                if (DRY_RUN) {
+                    console.log(chalk.cyan('\n🔍 DRY RUN — Changes that would be deployed:'));
+                    console.log(chalk.cyan(`   Options: ${newPayload.options.length}`));
+                    console.log(chalk.cyan(`   Experiences: ${newPayload.experiences.length}`));
+                    newPayload.experiences.forEach(exp => {
+                        const opts = exp.optionLocations.map(ol => `loc:${ol.locationLocalId}→opt:${ol.optionLocalId}`);
+                        console.log(chalk.cyan(`     ${exp.name}: [${opts.join(', ')}]`));
+                    });
+                    console.log(chalk.bold(chalk.yellow('\n⏭️  Skipped PUT — run without --dry-run to deploy.')));
+                } else {
+                    await axios.put(ACTIVITY_URL, newPayload, {
+                        headers: {
+                            'X-Api-Key': API_KEY,
+                            'Content-Type': 'application/vnd.adobe.target.v3+json',
+                            Authorization: `Bearer ${token}`
+                        }
+                    });
+                    fs.writeFileSync(DEPLOY_LOCK_FILE, String(Date.now()));
+                    console.log('New build deployed!');
+                }
+            }
+
+            const atUiLink = buildAtUiLink(activityType, activityId);
+            if (atUiLink) {
+                console.log(chalk.cyan(`\n🔗 Activity: ${atUiLink}`));
+            } else {
+                console.log(chalk.cyan(`\n🔗 Activity ID: ${activityId} (set ADOBE_TENANT in .env for a clickable link)`));
             }
             console.log(chalk.bold('---------------------------------'));
         };
 
-        const activity = await getActivity(activityId);
-        // console.log('Current activity:', activity);
-        await updateActivity(activity, activityId);
+        const activity = await getActivity();
+        await updateActivity(activity);
     } catch (err) {
         console.error(chalk.red('Error:'), err.response ? err.response.data : err.message);
         process.exit(1);