at-builder 1.2.2 → 1.2.3

package/src/services/doctor.ts

@@ -0,0 +1,383 @@
+import path from "path";
+import fs from "fs";
+import logger from "./logger";
+
+export interface DiagnosticIssue {
+    id: string;
+    severity: 'error' | 'warning';
+    message: string;
+    suggestion?: string;
+    fixable: boolean;
+    file?: string;
+}
+
+/**
+ * Run comprehensive diagnostics on the project
+ */
+export const runDiagnostics = async (projectPath: string, verbose: boolean = false): Promise<DiagnosticIssue[]> => {
+    const issues: DiagnosticIssue[] = [];
+    
+    if (verbose) logger.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;
+};
+
+/**
+ * Attempt to fix the provided issues
+ */
+export const fixIssues = async (issues: DiagnosticIssue[], projectPath: string, verbose: boolean = false): Promise<number> => {
+    let fixedCount = 0;
+    
+    for (const issue of issues) {
+        if (!issue.fixable) continue;
+        
+        try {
+            if (verbose) logger.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;
+};
+
+/**
+ * Fix a specific issue
+ */
+const fixIssue = async (issue: DiagnosticIssue, projectPath: string, verbose: boolean): Promise<boolean> => {
+    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: string, issues: DiagnosticIssue[]): Promise<void> => {
+    const envPath = path.join(projectPath, '.env');
+    
+    if (!fs.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.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: string, issues: DiagnosticIssue[]): Promise<void> => {
+    const configPath = path.join(projectPath, 'adobe.config.js');
+    
+    if (!fs.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: string, issues: DiagnosticIssue[]): Promise<void> => {
+    const configPath = path.join(projectPath, 'watch-config.json');
+    
+    if (!fs.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: string, issues: DiagnosticIssue[]): Promise<void> => {
+    const packagePath = path.join(projectPath, 'package.json');
+    
+    if (!fs.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: string, issues: DiagnosticIssue[]): Promise<void> => {
+    // Try to read ACTIVITIES_BASE_FOLDER from .env, fallback to default
+    let activitiesFolder = 'Activities';
+    const envPath = path.join(projectPath, '.env');
+    
+    if (fs.existsSync(envPath)) {
+        const envContent = fs.readFileSync(envPath, 'utf8');
+        const match = envContent.match(/ACTIVITIES_BASE_FOLDER=["']?([^"'\n\r]+)["']?/);
+        if (match) {
+            activitiesFolder = match[1];
+        }
+    }
+    
+    const activitiesPath = path.join(projectPath, activitiesFolder);
+    
+    if (!fs.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: string, issues: DiagnosticIssue[]): Promise<void> => {
+    const envPath = path.join(projectPath, '.env');
+    if (!fs.existsSync(envPath)) return;
+    
+    const envContent = fs.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: string, issues: DiagnosticIssue[]): Promise<void> => {
+    const packagePath = path.join(projectPath, 'package.json');
+    if (!fs.existsSync(packagePath)) return;
+    
+    const nodeModulesPath = path.join(projectPath, 'node_modules');
+    
+    if (!fs.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: string): Promise<boolean> => {
+    const envPath = path.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.writeFileSync(envPath, envContent, 'utf8');
+        return true;
+    } catch (error) {
+        return false;
+    }
+};
+
+const createAdobeConfig = async (projectPath: string): Promise<boolean> => {
+    const configPath = path.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.writeFileSync(configPath, configContent, 'utf8');
+        return true;
+    } catch (error) {
+        return false;
+    }
+};
+
+const createWatchConfig = async (projectPath: string): Promise<boolean> => {
+    const configPath = path.join(projectPath, 'watch-config.json');
+    const configContent = {
+        "VARIATION": "Variation-1"
+    };
+    
+    try {
+        fs.writeFileSync(configPath, JSON.stringify(configContent, null, 2), 'utf8');
+        return true;
+    } catch (error) {
+        return false;
+    }
+};
+
+const createActivitiesFolder = async (projectPath: string): Promise<boolean> => {
+    // Try to read ACTIVITIES_BASE_FOLDER from .env, fallback to default
+    let activitiesFolder = 'Activities';
+    const envPath = path.join(projectPath, '.env');
+    
+    if (fs.existsSync(envPath)) {
+        const envContent = fs.readFileSync(envPath, 'utf8');
+        const match = envContent.match(/ACTIVITIES_BASE_FOLDER=["']?([^"'\n\r]+)["']?/);
+        if (match) {
+            activitiesFolder = match[1];
+        }
+    }
+    
+    const activitiesPath = path.join(projectPath, activitiesFolder);
+    
+    try {
+        fs.mkdirSync(activitiesPath, { recursive: true });
+        return true;
+    } catch (error) {
+        return false;
+    }
+};
+
+const createPackageJson = async (projectPath: string): Promise<boolean> => {
+    const packagePath = path.join(projectPath, 'package.json');
+    const packageContent = {
+        "name": path.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.writeFileSync(packagePath, JSON.stringify(packageContent, null, 2), 'utf8');
+        return true;
+    } catch (error) {
+        return false;
+    }
+};

package/test-validation.js

@@ -0,0 +1,21 @@
+// Test validation logic
+const { spawn } = require('child_process');
+const path = require('path');
+
+console.log('Testing build command without .env file...');
+
+// Test without .env file
+const testDir = path.join(__dirname, 'test-empty');
+require('fs').mkdirSync(testDir, { recursive: true });
+
+const webpack = spawn('node', [path.join(__dirname, 'bin/index.js'), 'build'], {
+    cwd: testDir,
+    env: { ...process.env, ACTIVITY_FOLDER_NAME: '' },
+    stdio: 'inherit'
+});
+
+webpack.on('exit', (code) => {
+    console.log(`Build process exited with code: ${code}`);
+    // Clean up
+    require('fs').rmSync(testDir, { recursive: true, force: true });
+});

package/tsconfig.json

@@ -22,7 +22,7 @@
         "experimentalDecorators": true,
         "skipLibCheck": true,
         "esModuleInterop": true,
-        "resolveJsonModule": true,
+        "resolveJsonModule": true
     },
     "include": [
         "src/**/*",

package/webpack.config.js

@@ -74,7 +74,40 @@ var traversePath = function (dir) {
 
 // console.log("\x1b[33m%s\x1b[0m", `${process.env.ACTIVITY_FOLDER_NAME}`);
 
-var files = traversePath(path.join(PWD, 'Activities', process.env.ACTIVITY_FOLDER_NAME).toString());
+// Validate required environment variables
+if (!process.env.ACTIVITY_FOLDER_NAME || process.env.ACTIVITY_FOLDER_NAME.trim() === '') {
+    console.error('\x1b[31m%s\x1b[0m', '❌ Error: ACTIVITY_FOLDER_NAME environment variable is required but not set.');
+    console.error('\x1b[33m%s\x1b[0m', '💡 Please set ACTIVITY_FOLDER_NAME in your .env file or run "atb doctor --fix" to check your configuration.');
+    process.exit(1);
+}
+
+// Use configurable activities folder name from environment
+const ACTIVITIES_BASE_FOLDER = process.env.ACTIVITIES_BASE_FOLDER || 'Activities';
+const ACTIVITY_FOLDER = process.env.ACTIVITY_FOLDER_NAME.trim();
+
+console.log('\x1b[36m%s\x1b[0m', `📦 Building activity: ${ACTIVITY_FOLDER}`);
+console.log('\x1b[36m%s\x1b[0m', `📁 Activities folder: ${ACTIVITIES_BASE_FOLDER}`);
+
+// Check if the activity folder exists
+const activityPath = path.join(PWD, ACTIVITIES_BASE_FOLDER, ACTIVITY_FOLDER);
+if (!fs.existsSync(activityPath)) {
+    console.error('\x1b[31m%s\x1b[0m', `❌ Error: Activity folder not found: ${activityPath}`);
+    console.error('\x1b[33m%s\x1b[0m', '💡 Please check your ACTIVITY_FOLDER_NAME or create the activity folder first.');
+    console.error('\x1b[33m%s\x1b[0m', '💡 Run "atb new" to create a new activity or "atb doctor" to diagnose issues.');
+    process.exit(1);
+}
+
+var files = traversePath(activityPath.toString());
+
+// Check if we found any files to build
+if (!files || files.length === 0) {
+    console.error('\x1b[31m%s\x1b[0m', `❌ Error: No buildable files found in ${activityPath}`);
+    console.error('\x1b[33m%s\x1b[0m', '💡 Please ensure your activity folder contains variations (folders starting with "V") with .js or .ts files.');
+    console.error('\x1b[33m%s\x1b[0m', '💡 Expected structure: Activities/your-activity/Variation-1/index.js');
+    process.exit(1);
+}
+
+console.log('\x1b[36m%s\x1b[0m', `🔍 Found ${files.length} file(s) to build`);
 
 //Create entry object which is needed for webpack config
 var entries = {};