at-builder 1.2.8 → 1.3.3

package/bin/services/doctor.js

@@ -1,342 +1,804 @@
 "use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
+    return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.fixIssues = exports.runDiagnostics = void 0;
-const path_1 = __importDefault(require("path"));
-const fs_1 = __importDefault(require("fs"));
-const logger_1 = __importDefault(require("./logger"));
+var path_1 = __importDefault(require("path"));
+var fs_1 = __importDefault(require("fs"));
+var logger_1 = __importDefault(require("./logger"));
+var config_1 = require("../constants/config");
+// lib/install-checks.js is hand-written runtime JS (not TS-compiled). The
+// relative path resolves correctly from both src/services/doctor.ts (source)
+// and bin/services/doctor.js (compiled output) because src/ and bin/ have
+// parallel structure. Typed inline since the module isn't part of the TS graph.
+// eslint-disable-next-line @typescript-eslint/no-require-imports
+var installChecks = require("../../lib/install-checks");
 /**
  * Run comprehensive diagnostics on the project
  */
-const runDiagnostics = async (projectPath, verbose = false) => {
-    const issues = [];
-    if (verbose)
-        logger_1.default.info("runDiagnostics", `Running diagnostics on ${projectPath}`);
-    // Check for required files
-    await checkEnvFile(projectPath, issues);
-    await checkAdobeConfig(projectPath, issues);
-    await checkWatchConfig(projectPath, issues);
-    await checkPackageJson(projectPath, issues);
-    await checkActivitiesFolder(projectPath, issues);
-    // Check environment variables
-    await checkEnvVariables(projectPath, issues);
-    // Check dependencies
-    await checkDependencies(projectPath, issues);
-    return issues;
+var runDiagnostics = function (projectPath_1) {
+    var args_1 = [];
+    for (var _i = 1; _i < arguments.length; _i++) {
+        args_1[_i - 1] = arguments[_i];
+    }
+    return __awaiter(void 0, __spreadArray([projectPath_1], args_1, true), void 0, function (projectPath, verbose) {
+        var issues;
+        if (verbose === void 0) { verbose = false; }
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    issues = [];
+                    if (verbose)
+                        logger_1.default.info("runDiagnostics", "Running diagnostics on ".concat(projectPath));
+                    // Check for required files
+                    return [4 /*yield*/, checkEnvFile(projectPath, issues)];
+                case 1:
+                    // Check for required files
+                    _a.sent();
+                    return [4 /*yield*/, checkAdobeConfig(projectPath, issues)];
+                case 2:
+                    _a.sent();
+                    return [4 /*yield*/, checkWatchConfig(projectPath, issues)];
+                case 3:
+                    _a.sent();
+                    return [4 /*yield*/, checkGitignore(projectPath, issues)];
+                case 4:
+                    _a.sent();
+                    return [4 /*yield*/, checkPackageJson(projectPath, issues)];
+                case 5:
+                    _a.sent();
+                    return [4 /*yield*/, checkActivitiesFolder(projectPath, issues)];
+                case 6:
+                    _a.sent();
+                    // Check environment variables
+                    return [4 /*yield*/, checkEnvVariables(projectPath, issues)];
+                case 7:
+                    // Check environment variables
+                    _a.sent();
+                    // Check dependencies
+                    return [4 /*yield*/, checkDependencies(projectPath, issues)];
+                case 8:
+                    // Check dependencies
+                    _a.sent();
+                    // Check build.config.json content for every activity
+                    return [4 /*yield*/, checkBuildConfigs(projectPath, issues)];
+                case 9:
+                    // Check build.config.json content for every activity
+                    _a.sent();
+                    // Check install environment (PATH, atb shim, exec bit). Mirrors the
+                    // postinstall validator so users who installed with --ignore-scripts
+                    // (or who dismissed the postinstall warning) can still self-diagnose.
+                    return [4 /*yield*/, checkInstallEnv(issues)];
+                case 10:
+                    // Check install environment (PATH, atb shim, exec bit). Mirrors the
+                    // postinstall validator so users who installed with --ignore-scripts
+                    // (or who dismissed the postinstall warning) can still self-diagnose.
+                    _a.sent();
+                    return [2 /*return*/, issues];
+            }
+        });
+    });
 };
 exports.runDiagnostics = runDiagnostics;
 /**
  * Attempt to fix the provided issues
  */
-const fixIssues = async (issues, projectPath, verbose = false) => {
-    let fixedCount = 0;
-    for (const issue of issues) {
-        if (!issue.fixable)
-            continue;
-        try {
-            if (verbose)
-                logger_1.default.info("fixIssues", `Attempting to fix: ${issue.id}`);
-            const success = await fixIssue(issue, projectPath, verbose);
-            if (success) {
-                console.log(`✅ Fixed: ${issue.message}`);
-                fixedCount++;
-            }
-            else {
-                console.log(`❌ Could not fix: ${issue.message}`);
-            }
-        }
-        catch (error) {
-            console.log(`❌ Error fixing ${issue.id}: ${error.message}`);
-        }
+var fixIssues = function (issues_1, projectPath_1) {
+    var args_1 = [];
+    for (var _i = 2; _i < arguments.length; _i++) {
+        args_1[_i - 2] = arguments[_i];
     }
-    return fixedCount;
+    return __awaiter(void 0, __spreadArray([issues_1, projectPath_1], args_1, true), void 0, function (issues, projectPath, verbose) {
+        var fixedCount, _a, issues_2, issue, success, error_1;
+        if (verbose === void 0) { verbose = false; }
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    fixedCount = 0;
+                    _a = 0, issues_2 = issues;
+                    _b.label = 1;
+                case 1:
+                    if (!(_a < issues_2.length)) return [3 /*break*/, 6];
+                    issue = issues_2[_a];
+                    if (!issue.fixable)
+                        return [3 /*break*/, 5];
+                    _b.label = 2;
+                case 2:
+                    _b.trys.push([2, 4, , 5]);
+                    if (verbose)
+                        logger_1.default.info("fixIssues", "Attempting to fix: ".concat(issue.id));
+                    return [4 /*yield*/, fixIssue(issue, projectPath, verbose)];
+                case 3:
+                    success = _b.sent();
+                    if (success) {
+                        console.log("\u2705 Fixed: ".concat(issue.message));
+                        fixedCount++;
+                    }
+                    else {
+                        console.log("\u274C Could not fix: ".concat(issue.message));
+                    }
+                    return [3 /*break*/, 5];
+                case 4:
+                    error_1 = _b.sent();
+                    console.log("\u274C Error fixing ".concat(issue.id, ": ").concat(error_1.message));
+                    return [3 /*break*/, 5];
+                case 5:
+                    _a++;
+                    return [3 /*break*/, 1];
+                case 6: return [2 /*return*/, fixedCount];
+            }
+        });
+    });
 };
 exports.fixIssues = fixIssues;
 /**
  * Fix a specific issue
  */
-const fixIssue = async (issue, projectPath, verbose) => {
-    switch (issue.id) {
-        case 'missing-env':
-            return await createEnvFile(projectPath);
-        case 'missing-adobe-config':
-            return await createAdobeConfig(projectPath);
-        case 'missing-watch-config':
-            return await createWatchConfig(projectPath);
-        case 'missing-activities-folder':
-            return await createActivitiesFolder(projectPath);
-        case 'missing-package-json':
-            return await createPackageJson(projectPath);
-        default:
-            return false;
-    }
-};
+var fixIssue = function (issue, projectPath, verbose) { return __awaiter(void 0, void 0, void 0, function () {
+    var _a;
+    return __generator(this, function (_b) {
+        switch (_b.label) {
+            case 0:
+                _a = issue.id;
+                switch (_a) {
+                    case 'missing-env': return [3 /*break*/, 1];
+                    case 'missing-adobe-config': return [3 /*break*/, 3];
+                    case 'legacy-watch-config': return [3 /*break*/, 5];
+                    case 'missing-gitignore': return [3 /*break*/, 7];
+                    case 'missing-activities-folder': return [3 /*break*/, 9];
+                    case 'missing-package-json': return [3 /*break*/, 11];
+                }
+                return [3 /*break*/, 13];
+            case 1: return [4 /*yield*/, createEnvFile(projectPath)];
+            case 2: return [2 /*return*/, _b.sent()];
+            case 3: return [4 /*yield*/, createAdobeConfig(projectPath)];
+            case 4: return [2 /*return*/, _b.sent()];
+            case 5: return [4 /*yield*/, migrateWatchConfig(projectPath)];
+            case 6: return [2 /*return*/, _b.sent()];
+            case 7: return [4 /*yield*/, createGitignore(projectPath)];
+            case 8: return [2 /*return*/, _b.sent()];
+            case 9: return [4 /*yield*/, createActivitiesFolder(projectPath)];
+            case 10: return [2 /*return*/, _b.sent()];
+            case 11: return [4 /*yield*/, createPackageJson(projectPath)];
+            case 12: return [2 /*return*/, _b.sent()];
+            case 13: return [2 /*return*/, false];
+        }
+    });
+}); };
 /**
  * Check if .env file exists and has required variables
  */
-const checkEnvFile = async (projectPath, issues) => {
-    const envPath = path_1.default.join(projectPath, '.env');
-    if (!fs_1.default.existsSync(envPath)) {
-        issues.push({
-            id: 'missing-env',
-            severity: 'error',
-            message: '.env file is missing',
-            suggestion: 'Create .env file with required environment variables',
-            fixable: true,
-            file: '.env'
-        });
-        return;
-    }
-    // Check if .env has required variables
-    const envContent = fs_1.default.readFileSync(envPath, 'utf8');
-    const requiredVars = [
-        'ACTIVITIES_BASE_FOLDER',
-        'ACTIVITY_FOLDER_NAME',
-        'ADOBE_CLIENT_ID',
-        'ADOBE_CLIENT_SECRET'
-    ];
-    const missingVars = requiredVars.filter(varName => !envContent.includes(varName));
-    if (missingVars.length > 0) {
-        issues.push({
-            id: 'incomplete-env',
-            severity: 'warning',
-            message: `.env file missing variables: ${missingVars.join(', ')}`,
-            suggestion: 'Add missing environment variables to .env file',
-            fixable: true,
-            file: '.env'
-        });
-    }
-};
+var checkEnvFile = function (projectPath, issues) { return __awaiter(void 0, void 0, void 0, function () {
+    var envPath, envContent, requiredVars, missingVars;
+    return __generator(this, function (_a) {
+        envPath = path_1.default.join(projectPath, '.env');
+        if (!fs_1.default.existsSync(envPath)) {
+            issues.push({
+                id: 'missing-env',
+                severity: 'error',
+                message: '.env file is missing',
+                suggestion: 'Create .env file with required environment variables',
+                fixable: true,
+                file: '.env'
+            });
+            return [2 /*return*/];
+        }
+        envContent = fs_1.default.readFileSync(envPath, 'utf8');
+        requiredVars = [
+            'ACTIVITIES_BASE_FOLDER',
+            'ACTIVITY_FOLDER_NAME',
+            'ADOBE_CLIENT_ID',
+            'ADOBE_CLIENT_SECRET'
+        ];
+        missingVars = requiredVars.filter(function (varName) { return !envContent.includes(varName); });
+        if (missingVars.length > 0) {
+            issues.push({
+                id: 'incomplete-env',
+                severity: 'warning',
+                message: ".env file missing variables: ".concat(missingVars.join(', ')),
+                suggestion: 'Add missing environment variables to .env file',
+                fixable: true,
+                file: '.env'
+            });
+        }
+        return [2 /*return*/];
+    });
+}); };
 /**
  * Check if adobe.config.js exists
  */
-const checkAdobeConfig = async (projectPath, issues) => {
-    const configPath = path_1.default.join(projectPath, 'adobe.config.js');
-    if (!fs_1.default.existsSync(configPath)) {
-        issues.push({
-            id: 'missing-adobe-config',
-            severity: 'error',
-            message: 'adobe.config.js file is missing',
-            suggestion: 'Create Adobe Target API configuration file',
-            fixable: true,
-            file: 'adobe.config.js'
-        });
-    }
-};
+var checkAdobeConfig = function (projectPath, issues) { return __awaiter(void 0, void 0, void 0, function () {
+    var configPath;
+    return __generator(this, function (_a) {
+        configPath = path_1.default.join(projectPath, 'adobe.config.js');
+        if (!fs_1.default.existsSync(configPath)) {
+            issues.push({
+                id: 'missing-adobe-config',
+                severity: 'error',
+                message: 'adobe.config.js file is missing',
+                suggestion: 'Create Adobe Target API configuration file',
+                fixable: true,
+                file: 'adobe.config.js'
+            });
+        }
+        return [2 /*return*/];
+    });
+}); };
 /**
- * Check if watch-config.json exists
+ * Flag a legacy watch-config.json. As of this release VARIATION/PAGE live in
+ * .env; watch-config.json is supported as a fallback (puppeteer.js prefers it
+ * if present with a deprecation warning) but new projects don't get one.
+ *
+ * The fix migrates VARIATION/PAGE into .env and deletes watch-config.json.
  */
-const checkWatchConfig = async (projectPath, issues) => {
-    const configPath = path_1.default.join(projectPath, 'watch-config.json');
-    if (!fs_1.default.existsSync(configPath)) {
+var checkWatchConfig = function (projectPath, issues) { return __awaiter(void 0, void 0, void 0, function () {
+    var configPath;
+    return __generator(this, function (_a) {
+        configPath = path_1.default.join(projectPath, 'watch-config.json');
+        if (!fs_1.default.existsSync(configPath))
+            return [2 /*return*/];
         issues.push({
-            id: 'missing-watch-config',
+            id: 'legacy-watch-config',
             severity: 'warning',
-            message: 'watch-config.json file is missing',
-            suggestion: 'Create build configuration file',
+            message: 'watch-config.json is deprecated — VARIATION/PAGE now live in .env',
+            suggestion: 'Run "atb doctor --fix" to migrate values into .env and delete watch-config.json',
             fixable: true,
             file: 'watch-config.json'
         });
-    }
-};
+        return [2 /*return*/];
+    });
+}); };
+/**
+ * Check if .gitignore exists. Flags as a warning (not blocking) but fixable —
+ * `atb doctor --fix` writes the default template covering .env, .deploy-lock,
+ * dist/, etc. Does not modify an existing .gitignore.
+ */
+var checkGitignore = function (projectPath, issues) { return __awaiter(void 0, void 0, void 0, function () {
+    var gitignorePath;
+    return __generator(this, function (_a) {
+        gitignorePath = path_1.default.join(projectPath, '.gitignore');
+        if (!fs_1.default.existsSync(gitignorePath)) {
+            issues.push({
+                id: 'missing-gitignore',
+                severity: 'warning',
+                message: '.gitignore file is missing',
+                suggestion: 'Create .gitignore with at-builder defaults (.env, .deploy-lock, dist/, etc.)',
+                fixable: true,
+                file: '.gitignore'
+            });
+        }
+        return [2 /*return*/];
+    });
+}); };
 /**
  * Check if package.json exists
  */
-const checkPackageJson = async (projectPath, issues) => {
-    const packagePath = path_1.default.join(projectPath, 'package.json');
-    if (!fs_1.default.existsSync(packagePath)) {
-        issues.push({
-            id: 'missing-package-json',
-            severity: 'error',
-            message: 'package.json file is missing',
-            suggestion: 'Initialize npm project with package.json',
-            fixable: true,
-            file: 'package.json'
-        });
-    }
+var checkPackageJson = function (projectPath, issues) { return __awaiter(void 0, void 0, void 0, function () {
+    var packagePath;
+    return __generator(this, function (_a) {
+        packagePath = path_1.default.join(projectPath, 'package.json');
+        if (!fs_1.default.existsSync(packagePath)) {
+            issues.push({
+                id: 'missing-package-json',
+                severity: 'error',
+                message: 'package.json file is missing',
+                suggestion: 'Initialize npm project with package.json',
+                fixable: true,
+                file: 'package.json'
+            });
+        }
+        return [2 /*return*/];
+    });
+}); };
+/**
+ * Resolve the configured activities folder name. Reads ACTIVITIES_BASE_FOLDER
+ * from the consumer .env (matching webpack/at-deploy/at-sync resolution), falls
+ * back to the default "Activities".
+ */
+var resolveActivitiesFolderName = function (projectPath) {
+    var envPath = path_1.default.join(projectPath, '.env');
+    if (!fs_1.default.existsSync(envPath))
+        return 'Activities';
+    var envContent = fs_1.default.readFileSync(envPath, 'utf8');
+    var match = envContent.match(/ACTIVITIES_BASE_FOLDER=["']?([^"'\n\r]+)["']?/);
+    return match ? match[1] : 'Activities';
 };
 /**
  * Check if Activities folder exists
  */
-const checkActivitiesFolder = async (projectPath, issues) => {
-    // Try to read ACTIVITIES_BASE_FOLDER from .env, fallback to default
-    let activitiesFolder = 'Activities';
-    const envPath = path_1.default.join(projectPath, '.env');
-    if (fs_1.default.existsSync(envPath)) {
-        const envContent = fs_1.default.readFileSync(envPath, 'utf8');
-        const match = envContent.match(/ACTIVITIES_BASE_FOLDER=["']?([^"'\n\r]+)["']?/);
-        if (match) {
-            activitiesFolder = match[1];
+var checkActivitiesFolder = function (projectPath, issues) { return __awaiter(void 0, void 0, void 0, function () {
+    var activitiesFolder, activitiesPath;
+    return __generator(this, function (_a) {
+        activitiesFolder = resolveActivitiesFolderName(projectPath);
+        activitiesPath = path_1.default.join(projectPath, activitiesFolder);
+        if (!fs_1.default.existsSync(activitiesPath)) {
+            issues.push({
+                id: 'missing-activities-folder',
+                severity: 'warning',
+                message: "".concat(activitiesFolder, " folder is missing"),
+                suggestion: "Create ".concat(activitiesFolder, " folder for your activities"),
+                fixable: true,
+                file: activitiesFolder
+            });
         }
-    }
-    const activitiesPath = path_1.default.join(projectPath, activitiesFolder);
-    if (!fs_1.default.existsSync(activitiesPath)) {
-        issues.push({
-            id: 'missing-activities-folder',
-            severity: 'warning',
-            message: `${activitiesFolder} folder is missing`,
-            suggestion: `Create ${activitiesFolder} folder for your activities`,
-            fixable: true,
-            file: activitiesFolder
-        });
-    }
-};
+        return [2 /*return*/];
+    });
+}); };
+/**
+ * Validate every shared/build.config.json under the activities folder.
+ *
+ * Catches the deploy-time errors before deploy:
+ *   - missing or invalid activityType (must be "ab" or "xt")
+ *   - null id (deploy will fail when it tries to GET the activity)
+ *   - multi-page variation values without an activityInfo.pages map
+ *   - variation/page folders referenced in config but absent on disk
+ *
+ * Issues are not auto-fixable (they're content problems requiring human
+ * judgment), so each one is reported with a clear suggestion.
+ */
+var checkBuildConfigs = function (projectPath, issues) { return __awaiter(void 0, void 0, void 0, function () {
+    var activitiesFolder, activitiesPath, activityDirs, _i, activityDirs_1, activityDir, activityRoot, configCandidates, configPath, relConfig, parsed, activityInfo, activityType, variations, variationEntries, isMultiPage, pages, _a, variationEntries_1, _b, variationKey, variationValue, pagesMap, _c, _d, _e, pageName, subPath, folderAbs, _f, variationEntries_2, variationKey, folderAbs;
+    return __generator(this, function (_g) {
+        activitiesFolder = resolveActivitiesFolderName(projectPath);
+        activitiesPath = path_1.default.join(projectPath, activitiesFolder);
+        if (!fs_1.default.existsSync(activitiesPath))
+            return [2 /*return*/]; // already flagged elsewhere
+        activityDirs = fs_1.default.readdirSync(activitiesPath, { withFileTypes: true })
+            .filter(function (d) { return d.isDirectory() && !d.name.startsWith('.'); });
+        for (_i = 0, activityDirs_1 = activityDirs; _i < activityDirs_1.length; _i++) {
+            activityDir = activityDirs_1[_i];
+            activityRoot = path_1.default.join(activitiesPath, activityDir.name);
+            configCandidates = [
+                path_1.default.join(activityRoot, 'shared', 'build.config.json'),
+                path_1.default.join(activityRoot, 'Shared', 'build.config.json')
+            ];
+            configPath = configCandidates.find(function (p) { return fs_1.default.existsSync(p); });
+            if (!configPath)
+                continue; // missing build.config is its own concern
+            relConfig = path_1.default.relative(projectPath, configPath);
+            parsed = void 0;
+            try {
+                parsed = JSON.parse(fs_1.default.readFileSync(configPath, 'utf8'));
+            }
+            catch (err) {
+                issues.push({
+                    id: "invalid-build-config-json:".concat(activityDir.name),
+                    severity: 'error',
+                    message: "".concat(relConfig, " is not valid JSON"),
+                    suggestion: "Open ".concat(relConfig, " and fix the JSON syntax. Error: ").concat(err.message),
+                    fixable: false,
+                    file: relConfig
+                });
+                continue;
+            }
+            activityInfo = (parsed && parsed.activityInfo);
+            if (!activityInfo || typeof activityInfo !== 'object') {
+                issues.push({
+                    id: "missing-activity-info:".concat(activityDir.name),
+                    severity: 'error',
+                    message: "".concat(relConfig, " is missing activityInfo"),
+                    suggestion: 'Re-run "atb new" or restore activityInfo manually',
+                    fixable: false,
+                    file: relConfig
+                });
+                continue;
+            }
+            activityType = activityInfo.activityType;
+            if (!activityType) {
+                issues.push({
+                    id: "missing-activity-type:".concat(activityDir.name),
+                    severity: 'warning',
+                    message: "".concat(relConfig, " is missing activityType"),
+                    suggestion: 'Add `"activityType": "ab"` (or "xt") to activityInfo',
+                    fixable: false,
+                    file: relConfig
+                });
+            }
+            else if (!['ab', 'xt'].includes(String(activityType).toLowerCase())) {
+                issues.push({
+                    id: "invalid-activity-type:".concat(activityDir.name),
+                    severity: 'error',
+                    message: "".concat(relConfig, " has invalid activityType \"").concat(activityType, "\""),
+                    suggestion: 'activityType must be "ab" or "xt"',
+                    fixable: false,
+                    file: relConfig
+                });
+            }
+            // id check (warning only — null is fine until first deploy)
+            if (activityInfo.id === null || activityInfo.id === undefined) {
+                issues.push({
+                    id: "unset-activity-id:".concat(activityDir.name),
+                    severity: 'warning',
+                    message: "".concat(relConfig, " has no activity id (deploy will fail until set)"),
+                    suggestion: 'Set activityInfo.id once the activity exists in Adobe Target, or run "atb sync"',
+                    fixable: false,
+                    file: relConfig
+                });
+            }
+            variations = activityInfo.variations;
+            if (!variations || (Array.isArray(variations) && variations.length === 0) || (typeof variations === 'object' && !Array.isArray(variations) && Object.keys(variations).length === 0)) {
+                issues.push({
+                    id: "missing-variations:".concat(activityDir.name),
+                    severity: 'error',
+                    message: "".concat(relConfig, " has no variations"),
+                    suggestion: 'Add at least one variation to activityInfo.variations',
+                    fixable: false,
+                    file: relConfig
+                });
+                continue;
+            }
+            variationEntries = Array.isArray(variations)
+                ? []
+                : Object.entries(variations);
+            isMultiPage = variationEntries.some(function (_a) {
+                var v = _a[1];
+                return typeof v === 'object' && v !== null && 'pages' in v;
+            });
+            if (isMultiPage) {
+                pages = activityInfo.pages;
+                if (!pages || typeof pages !== 'object' || Object.keys(pages).length === 0) {
+                    issues.push({
+                        id: "multi-page-missing-pages:".concat(activityDir.name),
+                        severity: 'error',
+                        message: "".concat(relConfig, " uses multi-page variations but has no activityInfo.pages map"),
+                        suggestion: 'Add `"pages": { "<pageName>": <locationLocalId>, ... }` or run "atb sync" to populate it from Adobe Target',
+                        fixable: false,
+                        file: relConfig
+                    });
+                }
+                // Each multi-page variation: pages.<page> should map to a folder that exists
+                for (_a = 0, variationEntries_1 = variationEntries; _a < variationEntries_1.length; _a++) {
+                    _b = variationEntries_1[_a], variationKey = _b[0], variationValue = _b[1];
+                    if (typeof variationValue !== 'object' || variationValue === null || !('pages' in variationValue))
+                        continue;
+                    pagesMap = variationValue.pages || {};
+                    for (_c = 0, _d = Object.entries(pagesMap); _c < _d.length; _c++) {
+                        _e = _d[_c], pageName = _e[0], subPath = _e[1];
+                        if (typeof subPath !== 'string')
+                            continue;
+                        folderAbs = path_1.default.join(activityRoot, subPath);
+                        if (!fs_1.default.existsSync(folderAbs)) {
+                            issues.push({
+                                id: "missing-page-folder:".concat(activityDir.name, ":").concat(variationKey, ":").concat(pageName),
+                                severity: 'warning',
+                                message: "".concat(relConfig, ": variation \"").concat(variationKey, "\" \u2192 page \"").concat(pageName, "\" expects folder \"").concat(subPath, "\" but it doesn't exist"),
+                                suggestion: 'Run "atb sync --scaffold" to auto-create missing variation folders, or create them manually',
+                                fixable: false,
+                                file: relConfig
+                            });
+                        }
+                    }
+                }
+            }
+            else {
+                // Single-page: each variation key should map to a folder under the activity root
+                for (_f = 0, variationEntries_2 = variationEntries; _f < variationEntries_2.length; _f++) {
+                    variationKey = variationEntries_2[_f][0];
+                    folderAbs = path_1.default.join(activityRoot, variationKey);
+                    if (!fs_1.default.existsSync(folderAbs)) {
+                        issues.push({
+                            id: "missing-variation-folder:".concat(activityDir.name, ":").concat(variationKey),
+                            severity: 'warning',
+                            message: "".concat(relConfig, ": variation \"").concat(variationKey, "\" has no folder at ").concat(path_1.default.relative(projectPath, folderAbs)),
+                            suggestion: 'Create the folder, run "atb new" to scaffold variations, or remove the entry from build.config.json',
+                            fixable: false,
+                            file: relConfig
+                        });
+                    }
+                }
+            }
+        }
+        return [2 /*return*/];
+    });
+}); };
 /**
  * Check environment variables content
  */
-const checkEnvVariables = async (projectPath, issues) => {
-    const envPath = path_1.default.join(projectPath, '.env');
-    if (!fs_1.default.existsSync(envPath))
-        return;
-    const envContent = fs_1.default.readFileSync(envPath, 'utf8');
-    // Check if ACTIVITY_FOLDER_NAME is empty
-    if (envContent.includes('ACTIVITY_FOLDER_NAME=""') || envContent.includes('ACTIVITY_FOLDER_NAME=\'\'')) {
-        issues.push({
-            id: 'empty-activity-folder-name',
-            severity: 'warning',
-            message: 'ACTIVITY_FOLDER_NAME is empty',
-            suggestion: 'Set ACTIVITY_FOLDER_NAME to your activity folder name',
-            fixable: false
-        });
-    }
-    // Check if Adobe credentials are empty
-    if (envContent.includes('ADOBE_CLIENT_ID=""') || envContent.includes('ADOBE_CLIENT_ID=\'\'')) {
-        issues.push({
-            id: 'empty-adobe-client-id',
-            severity: 'warning',
-            message: 'ADOBE_CLIENT_ID is empty',
-            suggestion: 'Set your Adobe Target API client ID',
-            fixable: false
-        });
-    }
-    if (envContent.includes('ADOBE_CLIENT_SECRET=""') || envContent.includes('ADOBE_CLIENT_SECRET=\'\'')) {
-        issues.push({
-            id: 'empty-adobe-client-secret',
-            severity: 'warning',
-            message: 'ADOBE_CLIENT_SECRET is empty',
-            suggestion: 'Set your Adobe Target API client secret',
-            fixable: false
-        });
-    }
-};
+var checkEnvVariables = function (projectPath, issues) { return __awaiter(void 0, void 0, void 0, function () {
+    var envPath, envContent, tenantMatch, tenantValue;
+    return __generator(this, function (_a) {
+        envPath = path_1.default.join(projectPath, '.env');
+        if (!fs_1.default.existsSync(envPath))
+            return [2 /*return*/];
+        envContent = fs_1.default.readFileSync(envPath, 'utf8');
+        // Check if ACTIVITY_FOLDER_NAME is empty
+        if (envContent.includes('ACTIVITY_FOLDER_NAME=""') || envContent.includes('ACTIVITY_FOLDER_NAME=\'\'')) {
+            issues.push({
+                id: 'empty-activity-folder-name',
+                severity: 'warning',
+                message: 'ACTIVITY_FOLDER_NAME is empty',
+                suggestion: 'Set ACTIVITY_FOLDER_NAME to your activity folder name',
+                fixable: false
+            });
+        }
+        // Check if Adobe credentials are empty
+        if (envContent.includes('ADOBE_CLIENT_ID=""') || envContent.includes('ADOBE_CLIENT_ID=\'\'')) {
+            issues.push({
+                id: 'empty-adobe-client-id',
+                severity: 'warning',
+                message: 'ADOBE_CLIENT_ID is empty',
+                suggestion: 'Set your Adobe Target API client ID',
+                fixable: false
+            });
+        }
+        if (envContent.includes('ADOBE_CLIENT_SECRET=""') || envContent.includes('ADOBE_CLIENT_SECRET=\'\'')) {
+            issues.push({
+                id: 'empty-adobe-client-secret',
+                severity: 'warning',
+                message: 'ADOBE_CLIENT_SECRET is empty',
+                suggestion: 'Set your Adobe Target API client secret',
+                fixable: false
+            });
+        }
+        tenantMatch = envContent.match(/^ADOBE_TENANT=(.*)$/m);
+        tenantValue = tenantMatch ? tenantMatch[1].trim().replace(/^["']|["']$/g, '') : '';
+        if (!tenantValue) {
+            issues.push({
+                id: 'empty-adobe-tenant',
+                severity: 'warning',
+                message: 'ADOBE_TENANT is missing or empty',
+                suggestion: 'Set ADOBE_TENANT to your AT tenant slug (the segment after mc.adobe.io/ in the AT URL)',
+                fixable: false
+            });
+        }
+        return [2 /*return*/];
+    });
+}); };
 /**
  * Check dependencies
  */
-const checkDependencies = async (projectPath, issues) => {
-    const packagePath = path_1.default.join(projectPath, 'package.json');
-    if (!fs_1.default.existsSync(packagePath))
-        return;
-    const nodeModulesPath = path_1.default.join(projectPath, 'node_modules');
-    if (!fs_1.default.existsSync(nodeModulesPath)) {
-        issues.push({
-            id: 'missing-node-modules',
-            severity: 'warning',
-            message: 'node_modules folder is missing',
-            suggestion: 'Run "npm install" to install dependencies',
-            fixable: false
-        });
-    }
-};
+var checkDependencies = function (projectPath, issues) { return __awaiter(void 0, void 0, void 0, function () {
+    var packagePath, nodeModulesPath;
+    return __generator(this, function (_a) {
+        packagePath = path_1.default.join(projectPath, 'package.json');
+        if (!fs_1.default.existsSync(packagePath))
+            return [2 /*return*/];
+        nodeModulesPath = path_1.default.join(projectPath, 'node_modules');
+        if (!fs_1.default.existsSync(nodeModulesPath)) {
+            issues.push({
+                id: 'missing-node-modules',
+                severity: 'warning',
+                message: 'node_modules folder is missing',
+                suggestion: 'Run "npm install" to install dependencies',
+                fixable: false
+            });
+        }
+        return [2 /*return*/];
+    });
+}); };
+/**
+ * Validate that the at-builder global install is healthy:
+ *   - global npm bin is on PATH
+ *   - the `atb` shim exists in the global bin
+ *   - on POSIX, the shim and the package's bin/index.js are executable
+ *     (auto-chmods 755 if missing the bit)
+ *
+ * Same checks as lib/postinstall.js, just surfaced through `atb doctor` for
+ * users who installed with --ignore-scripts or dismissed the postinstall
+ * warning. Issues are flagged but not auto-fixable here — the suggested
+ * commands need to run in the user's shell, not in this Node process.
+ */
+var checkInstallEnv = function (issues) { return __awaiter(void 0, void 0, void 0, function () {
+    var result, _i, _a, problem;
+    return __generator(this, function (_b) {
+        try {
+            result = installChecks.checkInstallEnvironment();
+        }
+        catch (err) {
+            // Don't let a bug in install-checks block the rest of doctor.
+            logger_1.default.error("checkInstallEnv", "Skipped: ".concat(err.message));
+            return [2 /*return*/];
+        }
+        for (_i = 0, _a = result.problems; _i < _a.length; _i++) {
+            problem = _a[_i];
+            issues.push({
+                id: 'install-env',
+                severity: 'warning',
+                message: problem,
+                suggestion: result.isWin
+                    ? "On Windows: ensure ".concat(result.globalBin || 'your npm global bin (npm config get prefix)', " is on PATH, then reinstall: npm i -g at-builder")
+                    : "On macOS/Linux: chmod +x \"".concat(result.shimPath || 'atb shim', "\" and ensure ").concat(result.globalBin || '$(npm config get prefix)/bin', " is on PATH; then run: hash -r"),
+                fixable: false
+            });
+        }
+        return [2 /*return*/];
+    });
+}); };
 // Fix functions
-const createEnvFile = async (projectPath) => {
-    const envPath = path_1.default.join(projectPath, '.env');
-    const envContent = `ACTIVITIES_BASE_FOLDER="Activities"
-ACTIVITY_FOLDER_NAME=""
-PUPPETEER_LANDING_PAGE=""
-TARGET_URL=""
-LOGIN_URL=""
-VARIATION="Variation-1"
-NODE_ENV="development"
-VERBOSE=false
-
-# Adobe Target Deployment Configuration
-ADOBE_CLIENT_ID=""
-ADOBE_CLIENT_SECRET=""`;
-    try {
-        fs_1.default.writeFileSync(envPath, envContent, 'utf8');
-        return true;
-    }
-    catch (error) {
-        return false;
-    }
-};
-const createAdobeConfig = async (projectPath) => {
-    const configPath = path_1.default.join(projectPath, 'adobe.config.js');
-    const configContent = `/**
- * Adobe Target API Configuration
- * 
- * Configuration constants for Adobe Target API integration.
- * These values are used by the deployment script to connect to Adobe Target.
+var createEnvFile = function (projectPath) { return __awaiter(void 0, void 0, void 0, function () {
+    var envPath, envContent;
+    return __generator(this, function (_a) {
+        envPath = path_1.default.join(projectPath, '.env');
+        envContent = "ACTIVITIES_BASE_FOLDER=\"Activities\"\nACTIVITY_FOLDER_NAME=\"\"\nPUPPETEER_LANDING_PAGE=\"\"\nTARGET_URL=\"\"\nLOGIN_URL=\"\"\n\n# Dev-server selection (used by `atb dev --browser`).\n# Edit and save while puppeteer is running to hot-swap the previewed bundle.\n# PAGE is only meaningful for multi-page activities \u2014 leave empty otherwise.\nVARIATION=\"Variation-1\"\nPAGE=\"\"\n\nNODE_ENV=\"development\"\nVERBOSE=false\n\n# Adobe Target Deployment Configuration\n# ADOBE_TENANT is your AT tenant slug \u2014 find it in the AT URL after \"mc.adobe.io/\".\nADOBE_TENANT=\"\"\nADOBE_CLIENT_ID=\"\"\nADOBE_CLIENT_SECRET=\"\"";
+        try {
+            fs_1.default.writeFileSync(envPath, envContent, 'utf8');
+            return [2 /*return*/, true];
+        }
+        catch (error) {
+            return [2 /*return*/, false];
+        }
+        return [2 /*return*/];
+    });
+}); };
+var createAdobeConfig = function (projectPath) { return __awaiter(void 0, void 0, void 0, function () {
+    var configPath, configContent;
+    return __generator(this, function (_a) {
+        configPath = path_1.default.join(projectPath, 'adobe.config.js');
+        configContent = "/**\n * Adobe Target API Configuration\n *\n * Used by at-sync.js and at-deploy.js. BASE_URL is the activities root \u2014\n * callers append `${activityType}/${activityId}` (e.g. ab/12345, xt/67890).\n *\n * ADOBE_TENANT comes from the consumer .env. Both at-sync and at-deploy load\n * dotenv before requiring this file, so process.env is populated by the time\n * BASE_URL is built.\n */\n\nconst TENANT = process.env.ADOBE_TENANT || 'YOUR_TENANT';\n\nmodule.exports = {\n    BASE_URL: `https://mc.adobe.io/${TENANT}/target/activities/`,\n    IMS_TOKEN_URL: 'https://ims-na1.adobelogin.com/ims/token/v3',\n    IMS_SCOPE: 'openid,AdobeID,target_sdk,additional_info.projectedProductContext'\n};";
+        try {
+            fs_1.default.writeFileSync(configPath, configContent, 'utf8');
+            return [2 /*return*/, true];
+        }
+        catch (error) {
+            return [2 /*return*/, false];
+        }
+        return [2 /*return*/];
+    });
+}); };
+/**
+ * Migrate VARIATION/PAGE from a legacy watch-config.json into .env, then
+ * delete the watch-config.json. Idempotent: existing .env entries are
+ * overwritten so the migrated values win (matching puppeteer's runtime
+ * precedence — watch-config.json was the source of truth).
  */
-
-module.exports = {
-    BASE_URL_NEW: 'https://mc.adobe.io/ups/target/',
-    BASE_URL: 'https://mc.adobe.io/ups/target/activities/ab/',
-    IMS_TOKEN_URL: 'https://ims-na1.adobelogin.com/ims/token/v3',
-    IMS_SCOPE: 'openid,AdobeID,target_sdk,additional_info.projectedProductContext'
-};`;
-    try {
-        fs_1.default.writeFileSync(configPath, configContent, 'utf8');
-        return true;
-    }
-    catch (error) {
-        return false;
-    }
-};
-const createWatchConfig = async (projectPath) => {
-    const configPath = path_1.default.join(projectPath, 'watch-config.json');
-    const configContent = {
-        "VARIATION": "Variation-1"
-    };
-    try {
-        fs_1.default.writeFileSync(configPath, JSON.stringify(configContent, null, 2), 'utf8');
-        return true;
-    }
-    catch (error) {
-        return false;
-    }
-};
-const createActivitiesFolder = async (projectPath) => {
-    // Try to read ACTIVITIES_BASE_FOLDER from .env, fallback to default
-    let activitiesFolder = 'Activities';
-    const envPath = path_1.default.join(projectPath, '.env');
-    if (fs_1.default.existsSync(envPath)) {
-        const envContent = fs_1.default.readFileSync(envPath, 'utf8');
-        const match = envContent.match(/ACTIVITIES_BASE_FOLDER=["']?([^"'\n\r]+)["']?/);
-        if (match) {
-            activitiesFolder = match[1];
+var migrateWatchConfig = function (projectPath) { return __awaiter(void 0, void 0, void 0, function () {
+    var configPath, envPath, watchCfg, variation, page, envContent;
+    return __generator(this, function (_a) {
+        configPath = path_1.default.join(projectPath, 'watch-config.json');
+        envPath = path_1.default.join(projectPath, '.env');
+        if (!fs_1.default.existsSync(configPath))
+            return [2 /*return*/, true]; // nothing to migrate
+        try {
+            watchCfg = JSON.parse(fs_1.default.readFileSync(configPath, 'utf8'));
         }
+        catch (err) {
+            console.error("Failed to parse watch-config.json: ".concat(err.message));
+            return [2 /*return*/, false];
+        }
+        variation = (watchCfg.VARIATION || '').trim();
+        page = (watchCfg.PAGE || '').trim();
+        if (!fs_1.default.existsSync(envPath)) {
+            // No .env yet — synthesize a minimal one with just the migrated keys.
+            // The user can add the rest via `atb init` or by editing manually.
+            fs_1.default.writeFileSync(envPath, "VARIATION=\"".concat(variation, "\"\nPAGE=\"").concat(page, "\"\n"), 'utf8');
+        }
+        else {
+            envContent = fs_1.default.readFileSync(envPath, 'utf8');
+            envContent = upsertEnvLine(envContent, 'VARIATION', variation);
+            envContent = upsertEnvLine(envContent, 'PAGE', page);
+            fs_1.default.writeFileSync(envPath, envContent, 'utf8');
+        }
+        try {
+            fs_1.default.unlinkSync(configPath);
+        }
+        catch (err) {
+            console.error("Migrated values into .env, but failed to delete watch-config.json: ".concat(err.message));
+            return [2 /*return*/, false];
+        }
+        console.log("\u2713 Migrated VARIATION=\"".concat(variation, "\" PAGE=\"").concat(page, "\" from watch-config.json into .env"));
+        return [2 /*return*/, true];
+    });
+}); };
+/**
+ * Insert or replace a `KEY="value"` line in a .env file body. Preserves
+ * surrounding lines; appends if the key wasn't present.
+ */
+var upsertEnvLine = function (envContent, key, value) {
+    var line = "".concat(key, "=\"").concat(value, "\"");
+    var re = new RegExp("^".concat(key, "=.*$"), 'm');
+    if (re.test(envContent)) {
+        return envContent.replace(re, line);
     }
-    const activitiesPath = path_1.default.join(projectPath, activitiesFolder);
-    try {
-        fs_1.default.mkdirSync(activitiesPath, { recursive: true });
-        return true;
-    }
-    catch (error) {
-        return false;
-    }
-};
-const createPackageJson = async (projectPath) => {
-    const packagePath = path_1.default.join(projectPath, 'package.json');
-    const packageContent = {
-        "name": path_1.default.basename(projectPath),
-        "version": "1.0.0",
-        "description": "",
-        "main": "index.js",
-        "scripts": {
-            "test": "echo \"Error: no test specified\" && exit 1"
-        },
-        "keywords": [],
-        "author": "",
-        "license": "ISC"
-    };
-    try {
-        fs_1.default.writeFileSync(packagePath, JSON.stringify(packageContent, null, 2), 'utf8');
-        return true;
-    }
-    catch (error) {
-        return false;
-    }
+    if (!envContent.endsWith('\n'))
+        envContent += '\n';
+    return envContent + line + '\n';
 };
+var createGitignore = function (projectPath) { return __awaiter(void 0, void 0, void 0, function () {
+    var gitignorePath;
+    return __generator(this, function (_a) {
+        gitignorePath = path_1.default.join(projectPath, '.gitignore');
+        try {
+            fs_1.default.writeFileSync(gitignorePath, config_1.GITIGNORE_TEMPLATE, 'utf8');
+            return [2 /*return*/, true];
+        }
+        catch (error) {
+            return [2 /*return*/, false];
+        }
+        return [2 /*return*/];
+    });
+}); };
+var createActivitiesFolder = function (projectPath) { return __awaiter(void 0, void 0, void 0, function () {
+    var activitiesFolder, envPath, envContent, match, activitiesPath;
+    return __generator(this, function (_a) {
+        activitiesFolder = 'Activities';
+        envPath = path_1.default.join(projectPath, '.env');
+        if (fs_1.default.existsSync(envPath)) {
+            envContent = fs_1.default.readFileSync(envPath, 'utf8');
+            match = envContent.match(/ACTIVITIES_BASE_FOLDER=["']?([^"'\n\r]+)["']?/);
+            if (match) {
+                activitiesFolder = match[1];
+            }
+        }
+        activitiesPath = path_1.default.join(projectPath, activitiesFolder);
+        try {
+            fs_1.default.mkdirSync(activitiesPath, { recursive: true });
+            return [2 /*return*/, true];
+        }
+        catch (error) {
+            return [2 /*return*/, false];
+        }
+        return [2 /*return*/];
+    });
+}); };
+var createPackageJson = function (projectPath) { return __awaiter(void 0, void 0, void 0, function () {
+    var packagePath, packageContent;
+    return __generator(this, function (_a) {
+        packagePath = path_1.default.join(projectPath, 'package.json');
+        packageContent = {
+            "name": path_1.default.basename(projectPath),
+            "version": "1.0.0",
+            "description": "",
+            "main": "index.js",
+            "scripts": {
+                "test": "echo \"Error: no test specified\" && exit 1"
+            },
+            "keywords": [],
+            "author": "",
+            "license": "ISC"
+        };
+        try {
+            fs_1.default.writeFileSync(packagePath, JSON.stringify(packageContent, null, 2), 'utf8');
+            return [2 /*return*/, true];
+        }
+        catch (error) {
+            return [2 /*return*/, false];
+        }
+        return [2 /*return*/];
+    });
+}); };