abapgit-agent 1.7.2 → 1.8.0

package/src/commands/list.js

@@ -0,0 +1,143 @@
+/**
+ * List command - List ABAP objects in a package
+ */
+
+module.exports = {
+  name: 'list',
+  description: 'List ABAP objects in a package',
+  requiresAbapConfig: true,
+  requiresVersionCheck: true,
+
+  async execute(args, context) {
+    const { loadConfig, AbapHttp } = context;
+
+    const packageArgIndex = args.indexOf('--package');
+    if (packageArgIndex === -1) {
+      console.error('Error: --package parameter required');
+      console.error('Usage: abapgit-agent list --package <package> [--type <types>] [--name <pattern>] [--limit <n>] [--offset <n>] [--json]');
+      console.error('Example: abapgit-agent list --package \'$ZMY_PACKAGE\'');
+      console.error('Example: abapgit-agent list --package \'$ZMY_PACKAGE\' --type CLAS,INTF');
+      process.exit(1);
+    }
+
+    // Check if package value is missing
+    if (packageArgIndex + 1 >= args.length) {
+      console.error('Error: --package parameter value is missing');
+      process.exit(1);
+    }
+
+    const packageName = args[packageArgIndex + 1];
+
+    // Validate package name
+    if (!packageName || packageName.trim() === '') {
+      console.error('Error: --package parameter cannot be empty');
+      process.exit(1);
+    }
+
+    // Optional type parameter
+    const typeArgIndex = args.indexOf('--type');
+    const type = typeArgIndex !== -1 && typeArgIndex + 1 < args.length ? args[typeArgIndex + 1] : null;
+
+    // Optional name pattern
+    const nameArgIndex = args.indexOf('--name');
+    const name = nameArgIndex !== -1 && nameArgIndex + 1 < args.length ? args[nameArgIndex + 1] : null;
+
+    // Optional limit
+    const limitArgIndex = args.indexOf('--limit');
+    let limit = 100;
+    if (limitArgIndex !== -1 && limitArgIndex + 1 < args.length) {
+      limit = parseInt(args[limitArgIndex + 1], 10);
+      if (isNaN(limit) || limit < 1) {
+        console.error('Error: --limit must be a positive number');
+        process.exit(1);
+      }
+      if (limit > 1000) {
+        console.error('Error: --limit value too high (max: 1000)');
+        process.exit(1);
+      }
+    }
+
+    // Optional offset
+    const offsetArgIndex = args.indexOf('--offset');
+    let offset = 0;
+    if (offsetArgIndex !== -1 && offsetArgIndex + 1 < args.length) {
+      offset = parseInt(args[offsetArgIndex + 1], 10);
+      if (isNaN(offset) || offset < 0) {
+        console.error('Error: --offset must be a non-negative number');
+        process.exit(1);
+      }
+    }
+
+    // Optional json parameter
+    const jsonOutput = args.includes('--json');
+
+    const config = loadConfig();
+    const http = new AbapHttp(config);
+    const csrfToken = await http.fetchCsrfToken();
+
+    const data = {
+      package: packageName,
+      limit: limit,
+      offset: offset
+    };
+
+    if (type) {
+      data.type = type;
+    }
+
+    if (name) {
+      data.name = name;
+    }
+
+    const result = await http.post('/sap/bc/z_abapgit_agent/list', data, { csrfToken });
+
+    // Handle uppercase keys from ABAP
+    const success = result.SUCCESS || result.success;
+    const error = result.ERROR || result.error;
+    const objects = result.OBJECTS || result.objects || [];
+    const byType = result.BY_TYPE || result.by_type || [];
+    const total = result.TOTAL || result.total || 0;
+
+    if (!success || error) {
+      console.error(`\n  Error: ${error || 'Failed to list objects'}`);
+      process.exit(1);
+    }
+
+    if (jsonOutput) {
+      console.log(JSON.stringify(result, null, 2));
+    } else {
+      // Display human-readable output
+      let title = `Objects in ${packageName}`;
+      if (type) {
+        title += ` (${type} only`;
+        if (total !== objects.length) {
+          title += `, Total: ${total}`;
+        }
+        title += ')';
+      } else if (total !== objects.length) {
+        title += ` (Total: ${total})`;
+      }
+      console.log(`\n${title}\n`);
+
+      // Group objects by type
+      const objectsByType = {};
+      for (const obj of objects) {
+        const objType = (obj.TYPE || obj.type || '???').toUpperCase();
+        if (!objectsByType[objType]) {
+          objectsByType[objType] = [];
+        }
+        objectsByType[objType].push(obj.NAME || obj.name);
+      }
+
+      // Display grouped objects
+      for (const objType of Object.keys(objectsByType).sort()) {
+        const objNames = objectsByType[objType];
+        console.log(`  ${objType} (${objNames.length})`);
+        for (const objName of objNames) {
+          console.log(`    ${objName}`);
+        }
+        console.log('');
+      }
+    }
+  }
+};

package/src/commands/preview.js

@@ -0,0 +1,277 @@
+/**
+ * Preview command - Preview data from ABAP tables or CDS views
+ */
+
+module.exports = {
+  name: 'preview',
+  description: 'Preview data from ABAP tables or CDS views',
+  requiresAbapConfig: true,
+  requiresVersionCheck: true,
+
+  async execute(args, context) {
+    const { loadConfig, AbapHttp, validators } = context;
+
+    const objectsArgIndex = args.indexOf('--objects');
+    if (objectsArgIndex === -1 || objectsArgIndex + 1 >= args.length) {
+      console.error('Error: --objects parameter required');
+      console.error('Usage: abapgit-agent preview --objects <table1>,<view1>,... [--type <type>] [--limit <n>] [--offset <n>] [--where <condition>] [--columns <cols>] [--vertical] [--compact] [--json]');
+      console.error('Example: abapgit-agent preview --objects SFLIGHT');
+      console.error('Example: abapgit-agent preview --objects ZC_MY_CDS_VIEW --type DDLS');
+      console.error('Example: abapgit-agent preview --objects SFLIGHT --where "CARRID = \'AA\'"');
+      console.error('Example: abapgit-agent preview --objects SFLIGHT --offset 10 --limit 20');
+      process.exit(1);
+    }
+
+    const objects = args[objectsArgIndex + 1].split(',').map(o => o.trim().toUpperCase());
+    const typeArg = args.indexOf('--type');
+    const type = typeArg !== -1 ? args[typeArg + 1].toUpperCase() : null;
+    const limitArg = args.indexOf('--limit');
+    const limitRaw = limitArg !== -1 ? args[limitArg + 1] : null;
+    const limitParsed = parseInt(limitRaw, 10);
+    const limit = limitRaw && !limitRaw.startsWith('--') && !isNaN(limitParsed) ? Math.max(1, limitParsed) : 100;
+    const offsetArg = args.indexOf('--offset');
+    const offsetRaw = offsetArg !== -1 ? args[offsetArg + 1] : null;
+    const offsetParsed = parseInt(offsetRaw, 10);
+    const offset = offsetRaw && !offsetRaw.startsWith('--') && !isNaN(offsetParsed) ? Math.max(0, offsetParsed) : 0;
+    const whereArg = args.indexOf('--where');
+    const where = whereArg !== -1 ? args[whereArg + 1] : null;
+    const columnsArg = args.indexOf('--columns');
+    const columns = columnsArg !== -1 ? args[columnsArg + 1].split(',').map(c => c.trim().toUpperCase()) : null;
+    const verticalOutput = args.includes('--vertical');
+    const compactOutput = args.includes('--compact');
+    const jsonOutput = args.includes('--json');
+
+    console.log(`\n  Previewing ${objects.length} object(s)`);
+
+    const config = loadConfig();
+    const http = new AbapHttp(config);
+    const csrfToken = await http.fetchCsrfToken();
+
+    const data = {
+      objects: objects,
+      limit: Math.min(Math.max(1, limit), 500),
+      offset: Math.max(0, offset)
+    };
+
+    if (type) {
+      data.type = type;
+    }
+
+    if (where) {
+      data.where = validators.convertDatesInWhereClause(where);
+    }
+
+    if (columns) {
+      data.columns = columns;
+    }
+
+    const result = await http.post('/sap/bc/z_abapgit_agent/preview', data, { csrfToken });
+
+    // Handle uppercase keys from ABAP
+    const success = result.SUCCESS || result.success;
+    const previewObjects = result.OBJECTS || result.objects || [];
+    const message = result.MESSAGE || result.message || '';
+    const error = result.ERROR || result.error;
+
+    if (!success || error) {
+      console.error(`\n  Error: ${error || 'Failed to preview objects'}`);
+      return;
+    }
+
+    const pagination = result.PAGINATION || result.pagination || null;
+
+    if (jsonOutput) {
+      console.log(JSON.stringify(result, null, 2));
+    } else {
+      // Build pagination message
+      let paginationMsg = '';
+      const paginationTotal = pagination ? (pagination.TOTAL || pagination.total || 0) : 0;
+      const paginationHasMore = pagination ? (pagination.HAS_MORE || pagination.has_more || false) : false;
+      if (pagination && paginationTotal > 0) {
+        // Handle case where offset exceeds total
+        if (offset >= paginationTotal) {
+          paginationMsg = ` (Offset ${offset} exceeds total ${paginationTotal})`;
+        } else {
+          const start = offset + 1;
+          const end = Math.min(offset + limit, paginationTotal);
+          paginationMsg = ` (Showing ${start}-${end} of ${paginationTotal})`;
+          if (paginationHasMore) {
+            paginationMsg += ` — Use --offset ${offset + limit} to see more`;
+          }
+        }
+      }
+
+      console.log(`\n  ${message}${paginationMsg}`);
+      console.log('');
+
+      // Track if columns were explicitly specified
+      const columnsExplicit = columns !== null;
+
+      for (let i = 0; i < previewObjects.length; i++) {
+        const obj = previewObjects[i];
+        const objName = obj.NAME || obj.name || `Object ${i + 1}`;
+        const objType = obj.TYPE || obj.type || '';
+        const objTypeText = obj.TYPE_TEXT || obj.type_text || '';
+        // Parse rows - could be a JSON string or array
+        let rows = obj.ROWS || obj.rows || [];
+        if (typeof rows === 'string') {
+          try {
+            rows = JSON.parse(rows);
+          } catch (e) {
+            rows = [];
+          }
+        }
+        const fields = obj.FIELDS || obj.fields || [];
+        const rowCount = obj.ROW_COUNT || obj.row_count || 0;
+        const totalRows = obj.TOTAL_ROWS || obj.total_rows || 0;
+        const notFound = obj.NOT_FOUND || obj.not_found || false;
+        const accessDenied = obj.ACCESS_DENIED || obj.access_denied || false;
+
+        // Check if object was not found
+        if (notFound) {
+          console.log(`  ❌ ${objName} (${objTypeText})`);
+          console.log(`     Object not found: ${objName}`);
+          continue;
+        }
+
+        // Check if access denied
+        if (accessDenied) {
+          console.log(`  ❌ ${objName} (${objTypeText})`);
+          console.log(`     Access denied to: ${objName}`);
+          continue;
+        }
+
+        console.log(`  📊 Preview: ${objName} (${objTypeText})`);
+
+        // Check for errors first
+        const objError = obj.ERROR || obj.error;
+        if (objError) {
+          console.log(`     ❌ Error: ${objError}`);
+          continue;
+        }
+
+        if (rows.length === 0) {
+          console.log('     No data found');
+          continue;
+        }
+
+        // Get all unique field names from all rows
+        const allFields = new Set();
+        rows.forEach(row => {
+          Object.keys(row).forEach(key => allFields.add(key));
+        });
+        const allFieldNames = Array.from(allFields);
+
+        // Display as table - use fields metadata only if --columns was explicitly specified
+        let fieldNames;
+        let columnsAutoSelected = false;
+        if (columnsExplicit && fields && fields.length > 0) {
+          // Use fields from metadata (filtered by explicit --columns)
+          fieldNames = fields.map(f => f.FIELD || f.field);
+        } else {
+          // Use all fields - let terminal handle wrapping if needed
+          // Terminal width detection is unreliable without a proper TTY
+          fieldNames = allFieldNames;
+        }
+
+        // Calculate column widths - use reasonable defaults
+        const colWidths = {};
+        const maxColWidth = compactOutput ? 10 : 20;
+        fieldNames.forEach(field => {
+          let maxWidth = field.length;
+          rows.forEach(row => {
+            const value = String(row[field] || '');
+            maxWidth = Math.max(maxWidth, value.length);
+          });
+          // Cap at maxColWidth (truncates both headers and data in compact mode)
+          colWidths[field] = Math.min(maxWidth, maxColWidth);
+        });
+
+        // Render output - either vertical or table
+        if (verticalOutput) {
+          // Vertical format: each field on its own line
+          rows.forEach((row, rowIndex) => {
+            if (rows.length > 1) {
+              console.log(`\n  Row ${rowIndex + 1}:`);
+              console.log('  ' + '─'.repeat(30));
+            }
+            fieldNames.forEach(field => {
+              const value = String(row[field] || '');
+              console.log(`  ${field}: ${value}`);
+            });
+          });
+          console.log('');
+          continue;
+        }
+
+        // Build table header
+        let headerLine = '  ┌';
+        let separatorLine = '  ├';
+        fieldNames.forEach(field => {
+          const width = colWidths[field];
+          headerLine += '─'.repeat(width + 2) + '┬';
+          separatorLine += '─'.repeat(width + 2) + '┼';
+        });
+        headerLine = headerLine.slice(0, -1) + '┐';
+        separatorLine = separatorLine.slice(0, -1) + '┤';
+
+        // Build header row
+        let headerRow = '  │';
+        fieldNames.forEach(field => {
+          const width = colWidths[field];
+          let displayField = String(field);
+          if (displayField.length > width) {
+            displayField = displayField.slice(0, width - 3) + '...';
+          }
+          headerRow += ' ' + displayField.padEnd(width) + ' │';
+        });
+
+        console.log(headerLine);
+        console.log(headerRow);
+        console.log(separatorLine);
+
+        // Build data rows
+        rows.forEach(row => {
+          let dataRow = '  │';
+          fieldNames.forEach(field => {
+            const width = colWidths[field];
+            const value = String(row[field] || '');
+            const displayValue = value.length > width ? value.slice(0, width - 3) + '...' : value;
+            dataRow += ' ' + displayValue.padEnd(width) + ' │';
+          });
+          console.log(dataRow);
+        });
+
+        // Build bottom border
+        let bottomLine = '  └';
+        fieldNames.forEach(field => {
+          const width = colWidths[field];
+          bottomLine += '─'.repeat(width + 2) + '┴';
+        });
+        bottomLine = bottomLine.slice(0, -1) + '┘';
+        console.log(bottomLine);
+
+        // Show row count
+        if (totalRows > rowCount) {
+          console.log(`\n  Showing ${rowCount} of ${totalRows} rows`);
+        } else {
+          console.log(`\n  ${rowCount} row(s)`);
+        }
+
+        // Note about hidden columns only when --columns was explicitly specified
+        const columnsDisplayed = fieldNames.length;
+        let columnsHidden = [];
+
+        if (columnsExplicit) {
+          columnsHidden = obj.COLUMNS_HIDDEN || obj.columns_hidden || [];
+          if (columnsHidden.length > 0) {
+            console.log(`\n  ⚠️  ${columnsHidden.length} more columns hidden (${columnsHidden.join(', ')})`);
+            console.log('     Use --json for full data');
+          }
+        }
+
+        console.log('');
+      }
+    }
+  }
+};

package/src/commands/pull.js

@@ -0,0 +1,278 @@
+/**
+ * Pull command - Pull and activate ABAP objects from git repository
+ */
+
+module.exports = {
+  name: 'pull',
+  description: 'Pull and activate ABAP objects from git repository',
+  requiresAbapConfig: true,
+  requiresVersionCheck: true,
+
+  async execute(args, context) {
+    const { loadConfig, AbapHttp, gitUtils, getTransport } = context;
+
+    const urlArgIndex = args.indexOf('--url');
+    const branchArgIndex = args.indexOf('--branch');
+    const filesArgIndex = args.indexOf('--files');
+    const transportArgIndex = args.indexOf('--transport');
+
+    // Auto-detect git remote URL if not provided
+    let gitUrl = urlArgIndex !== -1 ? args[urlArgIndex + 1] : null;
+    let branch = branchArgIndex !== -1 ? args[branchArgIndex + 1] : gitUtils.getBranch();
+    let files = null;
+
+    // Transport: CLI arg takes priority, then config/environment, then null
+    let transportRequest = null;
+    if (transportArgIndex !== -1 && transportArgIndex + 1 < args.length) {
+      // Explicit --transport argument
+      transportRequest = args[transportArgIndex + 1];
+    } else {
+      // Fall back to config or environment variable
+      transportRequest = getTransport();
+    }
+
+    if (filesArgIndex !== -1 && filesArgIndex + 1 < args.length) {
+      files = args[filesArgIndex + 1].split(',').map(f => f.trim());
+    }
+
+    if (!gitUrl) {
+      gitUrl = gitUtils.getRemoteUrl();
+      if (!gitUrl) {
+        console.error('Error: Not in a git repository or no remote configured.');
+        console.error('Either run from a git repo, or specify --url <git-url>');
+        process.exit(1);
+      }
+      console.log(`📌 Auto-detected git remote: ${gitUrl}`);
+    }
+
+    await this.pull(gitUrl, branch, files, transportRequest, loadConfig, AbapHttp);
+  },
+
+  async pull(gitUrl, branch = 'main', files = null, transportRequest = null, loadConfig, AbapHttp) {
+    const TERM_WIDTH = process.stdout.columns || 80;
+
+    console.log(`\n🚀 Starting pull for: ${gitUrl}`);
+    console.log(`   Branch: ${branch}`);
+    if (files && files.length > 0) {
+      console.log(`   Files: ${files.join(', ')}`);
+    }
+    if (transportRequest) {
+      console.log(`   Transport Request: ${transportRequest}`);
+    }
+
+    try {
+      const config = loadConfig();
+
+      // Fetch CSRF token first
+      const http = new AbapHttp(config);
+      const csrfToken = await http.fetchCsrfToken();
+
+      // Prepare request data with git credentials
+      const data = {
+        url: gitUrl,
+        branch: branch,
+        username: config.gitUsername,
+        password: config.gitPassword
+      };
+
+      // Add files array if specified
+      if (files && files.length > 0) {
+        data.files = files;
+      }
+
+      // Add transport request if specified
+      if (transportRequest) {
+        data.transport_request = transportRequest;
+      }
+
+      const result = await http.post('/sap/bc/z_abapgit_agent/pull', data, { csrfToken });
+
+      console.log('\n');
+
+      // Display raw result for debugging
+      if (process.env.DEBUG) {
+        console.log('Raw result:', JSON.stringify(result, null, 2));
+      }
+
+      // Handle uppercase keys from ABAP
+      const success = result.SUCCESS || result.success;
+      const jobId = result.JOB_ID || result.job_id;
+      const message = result.MESSAGE || result.message;
+      const errorDetail = result.ERROR_DETAIL || result.error_detail;
+      const transportRequestUsed = result.TRANSPORT_REQUEST || result.transport_request;
+      const activatedCount = result.ACTIVATED_COUNT || result.activated_count || 0;
+      const failedCount = result.FAILED_COUNT || result.failed_count || 0;
+      const logMessages = result.LOG_MESSAGES || result.log_messages || [];
+      const activatedObjects = result.ACTIVATED_OBJECTS || result.activated_objects || [];
+      const failedObjects = result.FAILED_OBJECTS || result.failed_objects || [];
+
+      // Icon mapping for message types
+      const getIcon = (type) => {
+        const icons = {
+          'S': '✅',  // Success
+          'E': '❌',  // Error
+          'W': '⚠️',  // Warning
+          'A': '🛑'   // Abort
+        };
+        return icons[type] || '';
+      };
+
+      // Calculate display width accounting for emoji (2 cells) vs ASCII (1 cell)
+      const calcWidth = (str) => {
+        if (!str) return 0;
+        let width = 0;
+        let i = 0;
+        while (i < str.length) {
+          const code = str.codePointAt(i);
+          if (!code) break;
+          // Variation selectors (FE00-FE0F) and ZWJ (200D) take 0 width
+          if (code >= 0xFE00 && code <= 0xFE0F) {
+            i += 1;
+            continue;
+          }
+          if (code === 0x200D) {  // Zero width joiner
+            i += 1;
+            continue;
+          }
+          // Emoji and wide characters take 2 cells
+          if (code > 0xFFFF) {
+            width += 2;
+            i += 2;  // Skip surrogate pair
+          } else if (code > 127) {
+            width += 2;
+            i += 1;
+          } else {
+            width += 1;
+            i += 1;
+          }
+        }
+        return width;
+      };
+
+      // Pad string to display width
+      const padToWidth = (str, width) => {
+        const s = str || '';
+        const currentWidth = calcWidth(s);
+        return s + ' '.repeat(Math.max(0, width - currentWidth));
+      };
+
+      if (success === 'X' || success === true) {
+        console.log(`✅ Pull completed successfully!`);
+        console.log(`   Job ID: ${jobId || 'N/A'}`);
+        console.log(`   Message: ${message || 'N/A'}`);
+      } else {
+        console.log(`❌ Pull completed with errors!`);
+        console.log(`   Job ID: ${jobId || 'N/A'}`);
+        console.log(`   Message: ${message || 'N/A'}`);
+      }
+
+      // Display error detail if available
+      if (errorDetail && errorDetail.trim()) {
+        console.log(`\n📋 Error Details:`);
+        console.log('─'.repeat(TERM_WIDTH));
+        // Handle escaped newlines from ABAP JSON
+        const formattedDetail = errorDetail.replace(/\\n/g, '\n');
+        console.log(formattedDetail);
+      }
+
+      // Display all messages as table (from log_messages)
+      if (logMessages && logMessages.length > 0) {
+        console.log(`\n📋 Pull Log (${logMessages.length} messages):`);
+
+        // Calculate column widths based on terminal width
+        const tableWidth = Math.min(TERM_WIDTH, 120);
+        const iconCol = 4;  // Fixed width for icon column
+        const objCol = 28;
+        const msgCol = tableWidth - iconCol - objCol - 6; // Account for vertical lines (3 chars)
+
+        const headerLine = '─'.repeat(iconCol) + '┼' + '─'.repeat(objCol) + '┼' + '─'.repeat(msgCol);
+        const headerText = padToWidth('Icon', iconCol) + '│' + padToWidth('Object', objCol) + '│' + 'Message'.substring(0, msgCol);
+        const borderLine = '─'.repeat(tableWidth);
+
+        console.log(borderLine);
+        console.log(headerText);
+        console.log(headerLine);
+
+        for (const msg of logMessages) {
+          const icon = getIcon(msg.TYPE);
+          const objType = msg.OBJ_TYPE || '';
+          const objName = msg.OBJ_NAME || '';
+          const obj = objType && objName ? `${objType} ${objName}` : '';
+          const text = msg.TEXT || '';
+
+          // Truncate long text
+          const displayText = text.length > msgCol ? text.substring(0, msgCol - 3) + '...' : text;
+
+          console.log(padToWidth(icon, iconCol) + '│' + padToWidth(obj.substring(0, objCol), objCol) + '│' + displayText);
+        }
+      }
+
+      // Extract objects with errors from log messages (type 'E' = Error)
+      const failedObjectsFromLog = [];
+      const objectsWithErrors = new Set();
+
+      for (const msg of logMessages) {
+        if (msg.TYPE === 'E' && msg.OBJ_TYPE && msg.OBJ_NAME) {
+          const objKey = `${msg.OBJ_TYPE} ${msg.OBJ_NAME}`;
+          objectsWithErrors.add(objKey);
+          failedObjectsFromLog.push({
+            OBJ_TYPE: msg.OBJ_TYPE,
+            OBJ_NAME: msg.OBJ_NAME,
+            TEXT: msg.TEXT || 'Activation failed',
+            EXCEPTION: msg.EXCEPTION || ''
+          });
+        }
+      }
+
+      // Filter activated objects - only include objects without errors
+      const filteredActivatedObjects = activatedObjects.filter(obj => {
+        const objKey = obj.OBJ_TYPE && obj.OBJ_NAME ? `${obj.OBJ_TYPE} ${obj.OBJ_NAME}` : '';
+        return objKey && !objectsWithErrors.has(objKey);
+      });
+
+      // Display unique activated objects (excluding objects with errors)
+      if (filteredActivatedObjects && filteredActivatedObjects.length > 0) {
+        console.log(`\n📦 Activated Objects (${filteredActivatedObjects.length}):`);
+        console.log('─'.repeat(TERM_WIDTH));
+        for (const obj of filteredActivatedObjects) {
+          console.log(`✅ ${obj.OBJ_TYPE} ${obj.OBJ_NAME}`);
+        }
+      }
+
+      // Display failed objects log (all error messages, duplicates allowed)
+      if (failedObjectsFromLog.length > 0) {
+        console.log(`\n❌ Failed Objects Log (${failedObjectsFromLog.length} entries):`);
+        console.log('─'.repeat(TERM_WIDTH));
+        for (const obj of failedObjectsFromLog) {
+          const objKey = obj.OBJ_TYPE && obj.OBJ_NAME ? `${obj.OBJ_TYPE} ${obj.OBJ_NAME}` : '';
+          let text = obj.TEXT || 'Activation failed';
+          // Include exception text if available
+          if (obj.EXCEPTION && obj.EXCEPTION.trim()) {
+            text = `${text}\nException: ${obj.EXCEPTION}`;
+          }
+          console.log(`❌ ${objKey}: ${text}`);
+        }
+      } else if (failedObjects && failedObjects.length > 0) {
+        // Fallback to API failed_objects if no errors in log
+        console.log(`\n❌ Failed Objects Log (${failedObjects.length}):`);
+        console.log('─'.repeat(TERM_WIDTH));
+        for (const obj of failedObjects) {
+          const objKey = obj.OBJ_TYPE && obj.OBJ_NAME ? `${obj.OBJ_TYPE} ${obj.OBJ_NAME}` : '';
+          let text = obj.TEXT || 'Activation failed';
+          // Include exception text if available
+          if (obj.EXCEPTION && obj.EXCEPTION.trim()) {
+            text = `${text}\nException: ${obj.EXCEPTION}`;
+          }
+          console.log(`❌ ${objKey}: ${text}`);
+        }
+      } else if (failedCount > 0) {
+        console.log(`\n❌ Failed Objects Log (${failedCount})`);
+      }
+
+      return result;
+    } catch (error) {
+      console.error(`\n❌ Error: ${error.message}`);
+      process.exit(1);
+    }
+  }
+};