at-builder 1.2.2 → 1.2.3

package/.claude/settings.local.json

@@ -4,7 +4,8 @@
       "Bash(npm run build:prod:*)",
       "Bash(node:*)",
       "Bash(npx tsc:*)",
-      "Bash(find:*)"
+      "Bash(find:*)",
+      "Bash(rm:*)"
     ],
     "deny": []
   }

package/bin/constants/config.js

@@ -71,6 +71,10 @@ ${formatText("COMMANDS", 'yellow', true)}
     ${formatText("build --prod", 'cyan', true)}   Build for production deployment
     ${formatText("dev", 'cyan', true)}            Start development server with file watching
     ${formatText("dev --browser", 'cyan', true)}  Start development server and open in browser
+    ${formatText("deploy", 'cyan', true)}         Deploy activity to Adobe Target
+    ${formatText("deploy --dry-run", 'cyan', true)} Deploy in dry-run mode without actual deployment
+    ${formatText("doctor", 'cyan', true)}         Diagnose and fix project configuration issues
+    ${formatText("doctor --fix", 'cyan', true)}   Automatically fix detected configuration issues
     
 ${formatText("GLOBAL OPTIONS", 'yellow', true)}
     ${formatText("-v, --verbose", 'green')}       Enable detailed logging
@@ -92,6 +96,18 @@ ${formatText("EXAMPLES", 'yellow', true)}
     
     ${formatText("# Development server with browser", 'gray')}
     ${formatText("atb dev --browser", 'white')}
+    
+    ${formatText("# Deploy to Adobe Target", 'gray')}
+    ${formatText("atb deploy", 'white')}
+    
+    ${formatText("# Deploy in dry-run mode", 'gray')}
+    ${formatText("atb deploy --dry-run", 'white')}
+    
+    ${formatText("# Check project configuration", 'gray')}
+    ${formatText("atb doctor", 'white')}
+    
+    ${formatText("# Auto-fix configuration issues", 'gray')}
+    ${formatText("atb doctor --fix", 'white')}
 
 ${formatText("WORKFLOW", 'yellow', true)}
     ${formatText("1.", 'cyan')} Run ${formatText("atb init", 'white')} to set up project configuration
@@ -99,6 +115,7 @@ ${formatText("WORKFLOW", 'yellow', true)}
     ${formatText("3.", 'cyan')} Develop variations in ${formatText("/Activities/{name}/Variation-*/", 'gray')}
     ${formatText("4.", 'cyan')} Run ${formatText("atb build", 'white')} for development testing
     ${formatText("5.", 'cyan')} Run ${formatText("atb build --prod", 'white')} for Adobe Target deployment
+    ${formatText("6.", 'cyan')} Run ${formatText("atb deploy", 'white')} to deploy to Adobe Target
 
 ${formatText("SUPPORT", 'yellow', true)}
     Repository: ${formatText("https://github.com/upesenga/at-builder", 'blue')}
@@ -114,6 +131,7 @@ const setupEnv = async (basePath) => {
     if (!fs_1.default.existsSync(envPath)) {
         // Define the content of the .env file
         const envContent = `
+ACTIVITIES_BASE_FOLDER="Activities"
 ACTIVITY_FOLDER_NAME=""
 PUPPETEER_LANDING_PAGE=""
 TARGET_URL=""
@@ -121,6 +139,10 @@ LOGIN_URL=""
 VARIATION="Variation-1"
 NODE_ENV="development"
 VERBOSE=false
+
+# Adobe Target Deployment Configuration
+ADOBE_CLIENT_ID=""
+ADOBE_CLIENT_SECRET=""
     `;
         // Write the content to the .env file
         fs_1.default.writeFileSync(envPath, envContent.trim(), 'utf8');
@@ -130,6 +152,7 @@ VERBOSE=false
         console.log('.env file already exists!');
     }
     createWatchConfig(basePath);
+    createAdobeConfig(basePath);
 };
 exports.setupEnv = setupEnv;
 const createWatchConfig = (basePath) => {
@@ -148,6 +171,36 @@ const createWatchConfig = (basePath) => {
         console.log('watch-config.json file already exists!');
     }
 };
+const createAdobeConfig = (basePath) => {
+    // Path to the adobe.config.js file
+    const adobeConfigPath = path_1.default.join(basePath, 'adobe.config.js');
+    // Default content for adobe.config.js
+    const adobeConfigContent = `/**
+ * Adobe Target API Configuration
+ * 
+ * Configuration constants for Adobe Target API integration.
+ * These values are used by the deployment script to connect to Adobe Target.
+ */
+
+module.exports = {
+    // Adobe Target API base URL
+    BASE_URL: 'https://mc.adobe.io/target/activities/',
+    
+    // Adobe IMS (Identity Management Services) token endpoint
+    IMS_TOKEN_URL: 'https://ims-na1.adobelogin.com/ims/token/v1',
+    
+    // Required scopes for Adobe Target API access
+    IMS_SCOPE: 'openid,target_sdk'
+};`;
+    // Check if the adobe.config.js file already exists
+    if (!fs_1.default.existsSync(adobeConfigPath)) {
+        fs_1.default.writeFileSync(adobeConfigPath, adobeConfigContent, 'utf8');
+        console.log('adobe.config.js file created successfully!');
+    }
+    else {
+        console.log('adobe.config.js file already exists!');
+    }
+};
 /**
  * Reads and returns environment variables from the specified .env file
  * @param {string} basePath - The base path where the .env file is located

package/bin/index.js

@@ -9,6 +9,7 @@ const path_1 = __importDefault(require("path"));
 const fs_1 = __importDefault(require("fs"));
 const commander_1 = require("commander");
 const config_1 = require("./constants/config");
+const doctor_1 = require("./services/doctor");
 const logger_1 = __importDefault(require("./services/logger"));
 /**
  * Checks if the .env file exists at the current working directory
@@ -23,7 +24,9 @@ const checkEnvFile = () => {
         logger_1.default.info("checkEnvFile", ".env file found");
     }
     catch (error) {
-        // If the file does not exist, throw an error
+        // If the file does not exist, provide helpful guidance
+        console.error('\x1b[31m%s\x1b[0m', `❌ Error: .env file not found at ${process.cwd()}`);
+        console.error('\x1b[33m%s\x1b[0m', '💡 Run "atb init" to create .env file or "atb doctor --fix" to diagnose and fix configuration issues.');
         logger_1.default.error("checkEnvFile", `Error: Couldn't find .env file at location ${process.cwd()}`);
         throw error;
     }
@@ -76,6 +79,23 @@ const setupCommander = async () => {
         checkEnvFile();
         await handleDev(options.browser, globalOpts.verbose);
     });
+    program
+        .command('deploy')
+        .description('Deploy activity to Adobe Target using at-deploy.js')
+        .option('--dry-run', 'Run deployment in dry-run mode without actual deployment')
+        .action(async (options, command) => {
+        const globalOpts = command.parent.opts();
+        checkEnvFile();
+        await handleDeploy(options.dryRun, globalOpts.verbose);
+    });
+    program
+        .command('doctor')
+        .description('Diagnose and fix project configuration issues')
+        .option('--fix', 'Automatically fix detected issues')
+        .action(async (options, command) => {
+        const globalOpts = command.parent.opts();
+        await handleDoctor(options.fix, globalOpts.verbose);
+    });
     await program.parseAsync(process.argv);
     logger_1.default.info("setupCommander", "Commander setup complete");
 };
@@ -153,6 +173,61 @@ const handleDev = async (browser, verbose) => {
     logger_1.default.info("handleDev", `Running command: ${commandArr.join(', ')}`);
     runCommand(commandArr, productionEnv);
 };
+/**
+ * Handles the deploy command
+ */
+const handleDeploy = async (dryRun, verbose) => {
+    if (verbose)
+        logger_1.default.info("verbose", `Deploying to Adobe Target with dry-run=${dryRun}`);
+    logger_1.default.info("handleDeploy", "Running Adobe Target deployment");
+    // Set environment variables for the deployment script
+    const deployEnv = {
+        ...productionEnv,
+        VERBOSE: verbose.toString(),
+        DRY_RUN: dryRun.toString()
+    };
+    // Run the at-deploy.js script
+    runCommand(['run', 'deploy'], deployEnv);
+};
+/**
+ * Handles the doctor command
+ */
+const handleDoctor = async (autoFix, verbose) => {
+    if (verbose)
+        logger_1.default.info("verbose", `Running diagnostics with auto-fix=${autoFix}`);
+    logger_1.default.info("handleDoctor", "Diagnosing project configuration");
+    try {
+        // Run diagnostics
+        const issues = await (0, doctor_1.runDiagnostics)(process.cwd(), verbose);
+        if (issues.length === 0) {
+            console.log("✅ No issues found. Your project configuration is healthy!");
+            return;
+        }
+        // Display issues
+        console.log(`\n🔍 Found ${issues.length} issue(s):\n`);
+        issues.forEach((issue, index) => {
+            console.log(`${index + 1}. ${issue.severity === 'error' ? '❌' : '⚠️'} ${issue.message}`);
+            if (issue.suggestion) {
+                console.log(`   💡 ${issue.suggestion}`);
+            }
+        });
+        if (autoFix) {
+            console.log('\n🔧 Attempting to fix issues...\n');
+            const fixed = await (0, doctor_1.fixIssues)(issues, process.cwd(), verbose);
+            console.log(`\n✅ Fixed ${fixed} issue(s).`);
+            if (fixed < issues.length) {
+                console.log(`⚠️ ${issues.length - fixed} issue(s) require manual attention.`);
+            }
+        }
+        else {
+            console.log('\n💡 Run `atb doctor --fix` to automatically fix resolvable issues.');
+        }
+    }
+    catch (error) {
+        logger_1.default.error("handleDoctor", `Doctor command failed: ${error.message}`);
+        process.exit(1);
+    }
+};
 // Command execution logic
 /**
  * Main command execution entry point

package/bin/services/doctor.js

@@ -0,0 +1,346 @@
+"use strict";
+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"));
+/**
+ * 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;
+};
+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}`);
+        }
+    }
+    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;
+    }
+};
+/**
+ * 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'
+        });
+    }
+};
+/**
+ * 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'
+        });
+    }
+};
+/**
+ * Check if watch-config.json exists
+ */
+const checkWatchConfig = async (projectPath, issues) => {
+    const configPath = path_1.default.join(projectPath, 'watch-config.json');
+    if (!fs_1.default.existsSync(configPath)) {
+        issues.push({
+            id: 'missing-watch-config',
+            severity: 'warning',
+            message: 'watch-config.json file is missing',
+            suggestion: 'Create build configuration file',
+            fixable: true,
+            file: 'watch-config.json'
+        });
+    }
+};
+/**
+ * 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'
+        });
+    }
+};
+/**
+ * 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];
+        }
+    }
+    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
+        });
+    }
+};
+/**
+ * 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
+        });
+    }
+};
+/**
+ * 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
+        });
+    }
+};
+// 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.
+ */
+
+module.exports = {
+    // Adobe Target API base URL
+    BASE_URL: 'https://mc.adobe.io/target/activities/',
+    
+    // Adobe IMS (Identity Management Services) token endpoint
+    IMS_TOKEN_URL: 'https://ims-na1.adobelogin.com/ims/token/v1',
+    
+    // Required scopes for Adobe Target API access
+    IMS_SCOPE: 'openid,target_sdk'
+};`;
+    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];
+        }
+    }
+    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;
+    }
+};