@mcp-abap-adt/adt-backup 1.1.0 → 1.3.0

package/dist/lib/restore/restoreTreeBackup.js

@@ -1,11 +1,17 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.restoreTreeBackup = restoreTreeBackup;
+const fast_xml_parser_1 = require("fast-xml-parser");
 const logVerbose_1 = require("../cli/logVerbose");
 const flattenTree_1 = require("../tree/flattenTree");
 const getNodeObjectId_1 = require("../tree/getNodeObjectId");
 const analyzeDependencies_1 = require("./analyzeDependencies");
 const restoreTreeNode_1 = require("./restoreTreeNode");
+const xmlParser = new fast_xml_parser_1.XMLParser({
+    ignoreAttributes: false,
+    attributeNamePrefix: '@_',
+    parseAttributeValue: false,
+});
 const RESTORE_PHASES = [
     { name: 'Domains', types: ['domain'], activation: 'individual' },
     { name: 'Data Elements', types: ['dataElement'], activation: 'individual' },
@@ -21,6 +27,11 @@ const RESTORE_PHASES = [
     { name: 'Classes', types: ['class'], activation: 'individual' },
     { name: 'Interfaces', types: ['interface'], activation: 'individual' },
     { name: 'Programs', types: ['program'], activation: 'individual' },
+    {
+        name: 'Transformations',
+        types: ['transformation'],
+        activation: 'individual',
+    },
     {
         name: 'Function Groups',
         types: ['functionGroup'],
@@ -45,7 +56,7 @@ const RESTORE_PHASES = [
     { name: 'Service Bindings', types: ['serviceBinding'], activation: 'bulk' },
     { name: 'Enhancements', types: ['enhancement'], activation: 'individual' },
 ];
-async function restoreTreeBackup(client, root, mode, activate, transportRequest, restoreIds, restoreActions, activateOnCreate = true, softwareComponent, superPackageOverride, transportLayer) {
+async function restoreTreeBackup(client, root, mode, activate, transportRequest, restoreIds, planGroups, activateOnCreate = true, softwareComponent, superPackageOverride, transportLayer) {
     const allNodes = (0, flattenTree_1.flattenTree)(root).filter((node) => node.type && node.restoreStatus === 'ok');
     const nodes = restoreIds
         ? allNodes.filter((node) => {
@@ -57,68 +68,94 @@ async function restoreTreeBackup(client, root, mode, activate, transportRequest,
     const nonPackageNodes = nodes.filter((node) => node.type !== 'package');
     const backupPackageNames = new Set(packageNodes.map((node) => node.name));
     const rootPackageName = root.name;
-    (0, logVerbose_1.logVerbose)(1, `\n>>> STARTING TYPE-PHASE RESTORE: ${nodes.length} objects`);
-    const failures = [];
-    // Phase 1: Packages (recursive hierarchy)
-    if (packageNodes.length > 0) {
-        (0, logVerbose_1.logVerbose)(1, '[PHASE 1] Restoring package hierarchy...');
-        const restorePackageRecursive = async (node, parentName) => {
-            const nodeId = (0, getNodeObjectId_1.getNodeObjectId)(node);
-            if (node.type === 'package' &&
-                nodeId &&
-                (!restoreIds || restoreIds.has(nodeId))) {
-                const isRootNode = node.name === rootPackageName;
-                const nodeMode = (restoreActions?.get(nodeId) || mode);
-                const effectiveMode = isRootNode ? 'update' : nodeMode;
-                if (effectiveMode === 'skip') {
-                    (0, logVerbose_1.logVerbose)(2, `  [SKIP] package:${node.name}`);
-                }
-                else {
-                    (0, logVerbose_1.logVerbose)(2, `  [PACKAGE] ${node.name}`);
-                    try {
-                        await (0, restoreTreeNode_1.restoreTreeNode)(client, node, effectiveMode, false, transportRequest, softwareComponent, backupPackageNames, parentName || superPackageOverride, transportLayer);
-                    }
-                    catch (e) {
-                        if (isRootNode) {
-                            (0, logVerbose_1.logVerbose)(1, `  ! Warning: Root package ${node.name} already exists or update skipped.`);
-                        }
-                        else {
-                            throw e;
-                        }
-                    }
-                }
-            }
-            if (node.children) {
-                for (const child of node.children) {
-                    await restorePackageRecursive(child, node.type === 'package' ? node.name : parentName);
-                }
-            }
-        };
-        await restorePackageRecursive(root, undefined);
+    // Build restoreActions map from planGroups (if provided) for mode lookups
+    const restoreActions = planGroups
+        ? new Map(planGroups
+            .flatMap((g) => g.actions)
+            .map((a) => [a.id, a.action]))
+        : undefined;
+    // Build nodeMap for quick lookup by objectId (used in plan-driven path)
+    const nodeMap = new Map();
+    for (const node of allNodes) {
+        const id = (0, getNodeObjectId_1.getNodeObjectId)(node);
+        if (id)
+            nodeMap.set(id, node);
     }
-    // Phase 2: Analyze dependencies for processing order
-    (0, logVerbose_1.logVerbose)(1, `[PHASE 2] Analyzing dependencies for ${nonPackageNodes.length} objects...`);
-    const restoreGroups = (0, analyzeDependencies_1.analyzeDependencies)(nonPackageNodes);
-    const orderedNodes = restoreGroups.flatMap((g) => g.nodes);
-    (0, logVerbose_1.logVerbose)(1, `Dependency analysis complete: ${restoreGroups.length} groups → ${orderedNodes.length} ordered nodes.`);
-    // Helper to bulk activate a list of refs
+    const failures = [];
+    // Helper: check which of our refs are still inactive
+    const findInactiveRefs = async (refs) => {
+        const result = await client.getUtils().getInactiveObjects();
+        const inactiveSet = new Set(result.objects.map((o) => `${o.type}:${o.name}`.toUpperCase()));
+        return refs.filter((r) => inactiveSet.has(`${r.type}:${r.name}`.toUpperCase()));
+    };
+    // Helper to bulk activate a list of refs with verification
     const bulkActivate = async (phaseName, refs) => {
         if (refs.length === 0)
             return;
-        (0, logVerbose_1.logVerbose)(2, `  [*] Bulk activating ${phaseName} (${refs.length} objects)...`);
+        // Check which objects are actually inactive
+        let toActivate = await findInactiveRefs(refs);
+        if (toActivate.length === 0) {
+            (0, logVerbose_1.logVerbose)(2, `  [*] ${phaseName}: all ${refs.length} objects already active`);
+            return;
+        }
+        (0, logVerbose_1.logVerbose)(2, `  [*] Bulk activating ${phaseName} (${toActivate.length}/${refs.length} inactive)...`);
+        let hasErrors = false;
         try {
-            await client.getUtils().activateObjectsGroup(refs, true);
+            const result = await client
+                .getUtils()
+                .activateObjectsGroup(toActivate, true);
+            if (result?.data) {
+                const parsed = xmlParser.parse(typeof result.data === 'string' ? result.data : String(result.data));
+                const msgs = parsed?.['chkl:messages']?.msg;
+                if (msgs) {
+                    const msgArray = Array.isArray(msgs) ? msgs : [msgs];
+                    for (const msg of msgArray) {
+                        const type = msg['@_type'] || 'info';
+                        const text = msg?.shortText?.txt || msg?.shortText || String(msg);
+                        if (type === 'E')
+                            hasErrors = true;
+                        (0, logVerbose_1.logVerbose)(2, `    [${type}] ${text}`);
+                    }
+                }
+            }
         }
         catch (error) {
+            hasErrors = true;
             const message = error instanceof Error ? error.message : String(error);
-            (0, logVerbose_1.logVerbose)(1, `  [!] WARNING: ${phaseName} activation failed: ${message}`);
-            (0, logVerbose_1.logVerbose)(1, '  Objects are created but might be inactive. Continuing...');
+            (0, logVerbose_1.logVerbose)(2, `  [*] Activation request completed (${message})`);
+        }
+        // Verify: poll until our objects are no longer inactive (max 5 retries, 10s apart)
+        // Skip polling if activation returned errors
+        if (hasErrors) {
+            const stillInactive = await findInactiveRefs(refs);
+            if (stillInactive.length > 0) {
+                (0, logVerbose_1.logVerbose)(1, `  [!] WARNING: ${phaseName}: ${stillInactive.length} object(s) remain inactive:`);
+                for (const ref of stillInactive) {
+                    (0, logVerbose_1.logVerbose)(1, `      - ${ref.type}:${ref.name}`);
+                }
+            }
+            return;
+        }
+        const maxRetries = 5;
+        for (let attempt = 1; attempt <= maxRetries; attempt++) {
+            const stillInactive = await findInactiveRefs(refs);
+            if (stillInactive.length === 0) {
+                (0, logVerbose_1.logVerbose)(2, `  [*] ${phaseName}: all objects activated successfully`);
+                return;
+            }
+            if (attempt < maxRetries) {
+                (0, logVerbose_1.logVerbose)(2, `  [*] ${stillInactive.length} object(s) still inactive, waiting... (${attempt}/${maxRetries})`);
+                await new Promise((resolve) => setTimeout(resolve, 10000));
+            }
+            else {
+                (0, logVerbose_1.logVerbose)(1, `  [!] WARNING: ${phaseName}: ${stillInactive.length} object(s) remain inactive:`);
+                for (const ref of stillInactive) {
+                    (0, logVerbose_1.logVerbose)(1, `      - ${ref.type}:${ref.name}`);
+                }
+            }
         }
     };
-    // Phase 3: Process by granular type phases with per-type activation strategy
-    const knownTypes = new Set(RESTORE_PHASES.flatMap((p) => p.types));
-    const uncategorizedNodes = orderedNodes.filter((n) => n.type && !knownTypes.has(n.type) && n.type !== 'package');
-    // Helper: process a single node (create/update without activation)
+    // Helper: process a single node (create/update)
     const processNode = async (node, activateFlag) => {
         const nodeId = (0, getNodeObjectId_1.getNodeObjectId)(node);
         if (!nodeId)
@@ -148,64 +185,159 @@ async function restoreTreeBackup(client, root, mode, activate, transportRequest,
         }
         return null;
     };
-    const allProcessedRefs = [];
-    for (const phase of RESTORE_PHASES) {
-        const phaseTypeSet = new Set(phase.types);
-        const phaseNodes = orderedNodes.filter((n) => n.type && phaseTypeSet.has(n.type));
-        if (phaseNodes.length === 0)
-            continue;
-        (0, logVerbose_1.logVerbose)(1, `[${phase.name.toUpperCase()}] Processing ${phaseNodes.length} object(s) (${phase.activation})...`);
-        if (phase.activation === 'individual') {
-            // Activate each object at creation/update time
-            for (const node of phaseNodes) {
-                const ref = await processNode(node, true);
-                if (ref)
-                    allProcessedRefs.push(ref);
+    // Phase 1: Packages (recursive hierarchy) — shared by both paths
+    if (packageNodes.length > 0) {
+        (0, logVerbose_1.logVerbose)(1, '[PHASE 1] Restoring package hierarchy...');
+        const restorePackageRecursive = async (node, parentName) => {
+            const nodeId = (0, getNodeObjectId_1.getNodeObjectId)(node);
+            if (node.type === 'package' &&
+                nodeId &&
+                (!restoreIds || restoreIds.has(nodeId))) {
+                const isRootNode = node.name === rootPackageName;
+                const nodeMode = (restoreActions?.get(nodeId) || mode);
+                const effectiveMode = isRootNode ? 'update' : nodeMode;
+                if (effectiveMode === 'skip') {
+                    (0, logVerbose_1.logVerbose)(2, `  [SKIP] package:${node.name}`);
+                }
+                else {
+                    (0, logVerbose_1.logVerbose)(2, `  [PACKAGE] ${node.name}`);
+                    try {
+                        await (0, restoreTreeNode_1.restoreTreeNode)(client, node, effectiveMode, false, transportRequest, softwareComponent, backupPackageNames, parentName || superPackageOverride, transportLayer);
+                    }
+                    catch (e) {
+                        if (isRootNode) {
+                            (0, logVerbose_1.logVerbose)(1, `  ! Warning: Root package ${node.name} already exists or update skipped.`);
+                        }
+                        else {
+                            throw e;
+                        }
+                    }
+                }
             }
-        }
-        else if (phase.activation === 'bulk') {
-            // Create/update all without activation, then bulk activate together
-            const refs = [];
-            for (const node of phaseNodes) {
+            if (node.children) {
+                for (const child of node.children) {
+                    await restorePackageRecursive(child, node.type === 'package' ? node.name : parentName);
+                }
+            }
+        };
+        await restorePackageRecursive(root, undefined);
+    }
+    const allProcessedRefs = [];
+    if (planGroups) {
+        // ===== Plan-driven restore: follow plan group order =====
+        (0, logVerbose_1.logVerbose)(1, `\n>>> PLAN-DRIVEN RESTORE: ${planGroups.length} groups`);
+        for (const group of planGroups) {
+            const nonPackageActions = group.actions.filter((a) => a.type !== 'package');
+            if (nonPackageActions.length === 0)
+                continue;
+            (0, logVerbose_1.logVerbose)(1, `[GROUP ${group.id}] ${nonPackageActions.length} object(s)${group.isCircular ? ' (circular)' : ''}`);
+            const groupRefs = [];
+            for (const action of nonPackageActions) {
+                if (action.action === 'skip') {
+                    (0, logVerbose_1.logVerbose)(2, `  [SKIP] ${action.type}:${action.name}`);
+                    continue;
+                }
+                const node = nodeMap.get(action.id);
+                if (!node) {
+                    (0, logVerbose_1.logVerbose)(1, `  [WARN] Node not found for ${action.id}, skipping`);
+                    continue;
+                }
                 const ref = await processNode(node, false);
                 if (ref)
-                    refs.push(ref);
+                    groupRefs.push(ref);
             }
-            await bulkActivate(phase.name, refs);
-            allProcessedRefs.push(...refs);
+            if (groupRefs.length > 0) {
+                await bulkActivate(`Group ${group.id}${group.isCircular ? ' (circular)' : ''}`, groupRefs);
+            }
+            allProcessedRefs.push(...groupRefs);
         }
-        else if (phase.activation === 'cluster') {
-            // Cluster by dependencies (SCC groups), bulk activate per cluster
-            const groups = (0, analyzeDependencies_1.analyzeDependencies)(phaseNodes);
-            (0, logVerbose_1.logVerbose)(2, `  Dependency clustering: ${groups.length} cluster(s)`);
-            for (let gi = 0; gi < groups.length; gi++) {
-                const group = groups[gi];
-                const clusterRefs = [];
-                for (const node of group.nodes) {
+    }
+    else {
+        // ===== Fallback: type-phase restore (no plan) =====
+        (0, logVerbose_1.logVerbose)(1, `\n>>> STARTING TYPE-PHASE RESTORE: ${nodes.length} objects`);
+        (0, logVerbose_1.logVerbose)(1, `[PHASE 2] Analyzing dependencies for ${nonPackageNodes.length} objects...`);
+        const restoreGroups = (0, analyzeDependencies_1.analyzeDependencies)(nonPackageNodes);
+        const orderedNodes = restoreGroups.flatMap((g) => g.nodes);
+        (0, logVerbose_1.logVerbose)(1, `Dependency analysis complete: ${restoreGroups.length} groups → ${orderedNodes.length} ordered nodes.`);
+        const knownTypes = new Set(RESTORE_PHASES.flatMap((p) => p.types));
+        const uncategorizedNodes = orderedNodes.filter((n) => n.type && !knownTypes.has(n.type) && n.type !== 'package');
+        for (const phase of RESTORE_PHASES) {
+            const phaseTypeSet = new Set(phase.types);
+            const phaseNodes = orderedNodes.filter((n) => n.type && phaseTypeSet.has(n.type));
+            if (phaseNodes.length === 0)
+                continue;
+            (0, logVerbose_1.logVerbose)(1, `[${phase.name.toUpperCase()}] Processing ${phaseNodes.length} object(s) (${phase.activation})...`);
+            if (phase.activation === 'individual') {
+                for (const node of phaseNodes) {
+                    const ref = await processNode(node, true);
+                    if (ref)
+                        allProcessedRefs.push(ref);
+                }
+            }
+            else if (phase.activation === 'bulk') {
+                const refs = [];
+                for (const node of phaseNodes) {
                     const ref = await processNode(node, false);
                     if (ref)
-                        clusterRefs.push(ref);
+                        refs.push(ref);
                 }
-                if (clusterRefs.length > 0) {
-                    await bulkActivate(`${phase.name} cluster ${gi + 1}/${groups.length}${group.isCircular ? ' (circular)' : ''}`, clusterRefs);
+                await bulkActivate(phase.name, refs);
+                allProcessedRefs.push(...refs);
+            }
+            else if (phase.activation === 'cluster') {
+                const groups = (0, analyzeDependencies_1.analyzeDependencies)(phaseNodes);
+                (0, logVerbose_1.logVerbose)(2, `  Dependency clustering: ${groups.length} cluster(s)`);
+                for (let gi = 0; gi < groups.length; gi++) {
+                    const group = groups[gi];
+                    const clusterRefs = [];
+                    for (const node of group.nodes) {
+                        const ref = await processNode(node, false);
+                        if (ref)
+                            clusterRefs.push(ref);
+                    }
+                    if (clusterRefs.length > 0) {
+                        await bulkActivate(`${phase.name} cluster ${gi + 1}/${groups.length}${group.isCircular ? ' (circular)' : ''}`, clusterRefs);
+                    }
+                    allProcessedRefs.push(...clusterRefs);
                 }
-                allProcessedRefs.push(...clusterRefs);
             }
         }
-    }
-    // Uncategorized types (future types not in RESTORE_PHASES) — individual activation
-    if (uncategorizedNodes.length > 0) {
-        (0, logVerbose_1.logVerbose)(1, `[OTHER] Processing ${uncategorizedNodes.length} uncategorized object(s) (individual)...`);
-        for (const node of uncategorizedNodes) {
-            const ref = await processNode(node, true);
-            if (ref)
-                allProcessedRefs.push(ref);
+        if (uncategorizedNodes.length > 0) {
+            (0, logVerbose_1.logVerbose)(1, `[OTHER] Processing ${uncategorizedNodes.length} uncategorized object(s) (individual)...`);
+            for (const node of uncategorizedNodes) {
+                const ref = await processNode(node, true);
+                if (ref)
+                    allProcessedRefs.push(ref);
+            }
         }
     }
-    // Final activation sweep — safety net for objects left inactive
+    // Final check: find remaining inactive objects and activate them
     if (allProcessedRefs.length > 0) {
-        (0, logVerbose_1.logVerbose)(1, `[FINAL] Activation sweep (${allProcessedRefs.length} objects)...`);
-        await bulkActivate('Final sweep', allProcessedRefs);
+        const stillInactive = await findInactiveRefs(allProcessedRefs);
+        if (stillInactive.length > 0) {
+            (0, logVerbose_1.logVerbose)(1, `[FINAL] ${stillInactive.length} object(s) still inactive, activating...`);
+            try {
+                await client.getUtils().activateObjectsGroup(stillInactive, true);
+            }
+            catch (error) {
+                const message = error instanceof Error ? error.message : String(error);
+                (0, logVerbose_1.logVerbose)(2, `  [*] Final activation request completed (${message})`);
+            }
+            // Verify final state
+            const remaining = await findInactiveRefs(allProcessedRefs);
+            if (remaining.length > 0) {
+                (0, logVerbose_1.logVerbose)(1, `  [!] ${remaining.length} object(s) remain inactive:`);
+                for (const ref of remaining) {
+                    (0, logVerbose_1.logVerbose)(1, `      - ${ref.type}:${ref.name}`);
+                }
+            }
+            else {
+                (0, logVerbose_1.logVerbose)(1, '[FINAL] All objects activated successfully.');
+            }
+        }
+        else {
+            (0, logVerbose_1.logVerbose)(1, '[FINAL] All objects are active.');
+        }
     }
     if (failures.length > 0) {
         (0, logVerbose_1.logVerbose)(1, `\n>>> RESTORE COMPLETED WITH ${failures.length} FAILURE(S):`);

package/dist/lib/restore/restoreTreeNode.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"restoreTreeNode.d.ts","sourceRoot":"","sources":["../../../src/lib/restore/restoreTreeNode.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,SAAS,EAoBV,MAAM,2BAA2B,CAAC;AAGnC,OAAO,KAAK,EAAE,cAAc,EAAE,WAAW,EAAE,MAAM,UAAU,CAAC;AAO5D,wBAAsB,eAAe,CACnC,MAAM,EAAE,SAAS,EACjB,IAAI,EAAE,cAAc,EACpB,IAAI,EAAE,WAAW,EACjB,QAAQ,EAAE,OAAO,EACjB,gBAAgB,CAAC,EAAE,MAAM,EACzB,yBAAyB,CAAC,EAAE,MAAM,EAClC,kBAAkB,CAAC,EAAE,GAAG,CAAC,MAAM,CAAC,EAChC,oBAAoB,CAAC,EAAE,MAAM,EAC7B,sBAAsB,CAAC,EAAE,MAAM,GAC9B,OAAO,CAAC,IAAI,CAAC,CA8Zf"}
+{"version":3,"file":"restoreTreeNode.d.ts","sourceRoot":"","sources":["../../../src/lib/restore/restoreTreeNode.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,SAAS,EAqBV,MAAM,2BAA2B,CAAC;AAGnC,OAAO,KAAK,EAAE,cAAc,EAAE,WAAW,EAAE,MAAM,UAAU,CAAC;AAQ5D,wBAAsB,eAAe,CACnC,MAAM,EAAE,SAAS,EACjB,IAAI,EAAE,cAAc,EACpB,IAAI,EAAE,WAAW,EACjB,QAAQ,EAAE,OAAO,EACjB,gBAAgB,CAAC,EAAE,MAAM,EACzB,yBAAyB,CAAC,EAAE,MAAM,EAClC,kBAAkB,CAAC,EAAE,GAAG,CAAC,MAAM,CAAC,EAChC,oBAAoB,CAAC,EAAE,MAAM,EAC7B,sBAAsB,CAAC,EAAE,MAAM,GAC9B,OAAO,CAAC,IAAI,CAAC,CAibf"}

package/dist/lib/restore/restoreTreeNode.js

@@ -4,6 +4,7 @@ exports.restoreTreeNode = restoreTreeNode;
 const logVerbose_1 = require("../cli/logVerbose");
 const decodeBase64_1 = require("../crypto/decodeBase64");
 const asConfig_1 = require("../utils/asConfig");
+const detectTransformationType_1 = require("../utils/detectTransformationType");
 const ensureDescription_1 = require("../utils/ensureDescription");
 const parseBdefSource_1 = require("../utils/parseBdefSource");
 const parsePackageConfig_1 = require("../xml/parsePackageConfig");
@@ -190,6 +191,22 @@ async function restoreTreeNode(client, node, mode, activate, transportRequest, s
                 }
                 return;
             }
+            case 'transformation': {
+                const transformationType = (0, detectTransformationType_1.detectTransformationType)(payload);
+                const baseTxConfig = { ...config, transformationType };
+                if (mode !== 'update') {
+                    await client
+                        .getTransformation()
+                        .create((0, asConfig_1.asConfig)(baseTxConfig), options);
+                }
+                if (payload) {
+                    await client.getTransformation().update((0, asConfig_1.asConfig)({
+                        ...baseTxConfig,
+                        sourceCode: payload,
+                    }), options);
+                }
+                return;
+            }
             case 'functionGroup': {
                 if (mode !== 'update') {
                     await client

package/dist/lib/run.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"run.d.ts","sourceRoot":"","sources":["../../src/lib/run.ts"],"names":[],"mappings":"AAiDA,wBAAsB,GAAG,IAAI,OAAO,CAAC,IAAI,CAAC,CAgpBzC"}
+{"version":3,"file":"run.d.ts","sourceRoot":"","sources":["../../src/lib/run.ts"],"names":[],"mappings":"AAyDA,wBAAsB,GAAG,IAAI,OAAO,CAAC,IAAI,CAAC,CAytBzC"}

package/dist/lib/run.js

@@ -41,6 +41,7 @@ const fs = __importStar(require("node:fs"));
 const path = __importStar(require("node:path"));
 const adt_clients_1 = require("@mcp-abap-adt/adt-clients");
 const connection_1 = require("@mcp-abap-adt/connection");
+const fast_xml_parser_1 = require("fast-xml-parser");
 const yaml_1 = __importDefault(require("yaml"));
 const getSapConfigFromBroker_1 = require("./auth/getSapConfigFromBroker");
 const backupObject_1 = require("./backup/backupObject");
@@ -76,6 +77,11 @@ const parseObjectSpec_1 = require("./utils/parseObjectSpec");
 const formatVerifyResultsText_1 = require("./verify/formatVerifyResultsText");
 const verifyBackup_1 = require("./verify/verifyBackup");
 const extractMetadata_1 = require("./xml/extractMetadata");
+const xmlParser = new fast_xml_parser_1.XMLParser({
+    ignoreAttributes: false,
+    attributeNamePrefix: '@_',
+    parseAttributeValue: false,
+});
 async function run() {
     const argv = process.argv.slice(2);
     const args = (0, parseArgs_1.parseArgs)(argv.slice(1));
@@ -272,7 +278,20 @@ async function run() {
         const allNodes = (0, flattenTree_1.flattenTree)(backup.root).filter((n) => n.type && n.restoreStatus === 'ok');
         const packageNodes = allNodes.filter((n) => n.type === 'package');
         const nonPackageNodes = allNodes.filter((n) => n.type !== 'package');
-        const groups = (0, analyzeDependencies_1.analyzeDependencies)(nonPackageNodes);
+        // Dependency-based grouping: SCCs merged by dependency level
+        const depGroups = (0, analyzeDependencies_1.analyzeDependencyLevels)(nonPackageNodes);
+        const nonPackageGroups = depGroups.map((group, i) => ({
+            id: i + 1,
+            isCircular: group.isCircular,
+            actions: group.nodes.map((node) => ({
+                id: (0, getNodeObjectId_1.getNodeObjectId)(node),
+                type: node.type,
+                name: node.name,
+                functionGroupName: node.functionGroupName,
+                action: mode,
+                adtType: node.adtType,
+            })),
+        }));
         const plan = {
             schemaVersion: 1,
             generatedAt: new Date().toISOString(),
@@ -290,18 +309,7 @@ async function run() {
                         adtType: node.adtType,
                     })),
                 },
-                ...groups.map((group, idx) => ({
-                    id: idx + 1,
-                    isCircular: group.isCircular,
-                    actions: group.nodes.map((node) => ({
-                        id: (0, getNodeObjectId_1.getNodeObjectId)(node),
-                        type: node.type,
-                        name: node.name,
-                        functionGroupName: node.functionGroupName,
-                        action: mode,
-                        adtType: node.adtType,
-                    })),
-                })),
+                ...nonPackageGroups,
             ],
         };
         fs.writeFileSync(output, yaml_1.default.stringify(plan, { lineWidth: 0 }), 'utf8');
@@ -382,9 +390,7 @@ async function run() {
         const transportLayer = typeof args['transport-layer'] === 'string'
             ? args['transport-layer']
             : undefined;
-        await (0, restoreTreeBackup_1.restoreTreeBackup)(client, backup.root, 'upsert', activate, typeof args.transport === 'string' ? args.transport : undefined, undefined, new Map(plan.groups
-            .flatMap((g) => g.actions)
-            .map((a) => [a.id, a.action])), activateOnCreate, typeof args['software-component'] === 'string'
+        await (0, restoreTreeBackup_1.restoreTreeBackup)(client, backup.root, 'upsert', activate, typeof args.transport === 'string' ? args.transport : undefined, undefined, plan.groups, activateOnCreate, typeof args['software-component'] === 'string'
             ? args['software-component']
             : undefined, superPackage, transportLayer);
         console.log('Restore completed. Running post-restore check on TARGET system...');
@@ -405,54 +411,107 @@ async function run() {
             throw new Error(`Invalid --filter value: "${filter}". Must be skip, update, or all.`);
         }
         const plan = yaml_1.default.parse(fs.readFileSync(planPath, 'utf8'));
-        const allActions = plan.groups.flatMap((g) => g.actions);
-        const filtered = allActions.filter((a) => {
-            if (a.type === 'package')
-                return false;
-            if (!a.adtType)
-                return false;
-            if (filter === 'all')
-                return a.action !== 'create';
-            return a.action === filter;
-        });
-        if (filtered.length === 0) {
+        // Collect all plan refs (non-package, matching filter)
+        const planRefs = [];
+        for (const group of plan.groups) {
+            for (const action of group.actions) {
+                if (action.type === 'package' || !action.adtType)
+                    continue;
+                if (filter !== 'all' && action.action !== filter)
+                    continue;
+                if (filter === 'all' && action.action === 'create')
+                    continue;
+                planRefs.push({ name: action.name, type: action.adtType });
+            }
+        }
+        if (planRefs.length === 0) {
             console.log('No objects to activate.');
             return;
         }
-        console.log(`Activating ${filtered.length} object(s) (filter: ${filter})...`);
-        // Group by plan groups to respect dependency order
+        // Check which plan objects are actually inactive
+        const inactiveResult = await client.getUtils().getInactiveObjects();
+        const inactiveSet = new Set(inactiveResult.objects.map((o) => `${o.type}:${o.name}`.toUpperCase()));
+        const toActivate = planRefs.filter((r) => inactiveSet.has(`${r.type}:${r.name}`.toUpperCase()));
+        const alreadyActive = planRefs.length - toActivate.length;
+        if (toActivate.length === 0) {
+            console.log(`All ${planRefs.length} object(s) are already active. Nothing to activate.`);
+            return;
+        }
+        console.log(`Found ${toActivate.length} inactive object(s) out of ${planRefs.length} (${alreadyActive} already active). Activating...`);
+        // Group inactive objects by plan groups to respect dependency order
         let activated = 0;
-        let skipped = 0;
         let failed = 0;
         for (const group of plan.groups) {
             const groupRefs = [];
             for (const action of group.actions) {
                 if (action.type === 'package' || !action.adtType)
                     continue;
-                if (filter !== 'all' && action.action !== filter)
-                    continue;
-                if (filter === 'all' && action.action === 'create')
-                    continue;
-                groupRefs.push({ name: action.name, type: action.adtType });
+                const key = `${action.adtType}:${action.name}`.toUpperCase();
+                if (inactiveSet.has(key)) {
+                    groupRefs.push({ name: action.name, type: action.adtType });
+                }
             }
             if (groupRefs.length === 0)
                 continue;
-            (0, logVerbose_1.logVerbose)(2, `  [GROUP ${group.id}] Activating ${groupRefs.length} object(s)...`);
+            (0, logVerbose_1.logVerbose)(2, `  [GROUP ${group.id}] Activating ${groupRefs.length} inactive object(s)...`);
+            let hasErrors = false;
             try {
-                await client.getUtils().activateObjectsGroup(groupRefs, true);
-                activated += groupRefs.length;
-                for (const ref of groupRefs) {
-                    (0, logVerbose_1.logVerbose)(2, `    OK ${ref.type} ${ref.name}`);
+                const result = await client
+                    .getUtils()
+                    .activateObjectsGroup(groupRefs, true);
+                // Parse activation result messages
+                if (result?.data) {
+                    const parsed = xmlParser.parse(typeof result.data === 'string' ? result.data : String(result.data));
+                    const msgs = parsed?.['chkl:messages']?.msg;
+                    if (msgs) {
+                        const msgArray = Array.isArray(msgs) ? msgs : [msgs];
+                        for (const msg of msgArray) {
+                            const type = msg['@_type'] || 'info';
+                            const text = msg?.shortText?.txt || msg?.shortText || String(msg);
+                            if (type === 'E')
+                                hasErrors = true;
+                            (0, logVerbose_1.logVerbose)(2, `    [${type}] ${text}`);
+                        }
+                    }
                 }
             }
             catch (error) {
+                hasErrors = true;
                 const message = error instanceof Error ? error.message : String(error);
-                failed += groupRefs.length;
-                (0, logVerbose_1.logVerbose)(1, `  [!] Group ${group.id} activation failed: ${message}`);
+                (0, logVerbose_1.logVerbose)(2, `  [*] Activation request completed (${message})`);
+            }
+            // Poll until objects are no longer inactive (max 5 retries, 10s apart)
+            // Skip polling if activation returned errors (no point waiting)
+            if (!hasErrors) {
+                const maxRetries = 5;
+                for (let attempt = 1; attempt <= maxRetries; attempt++) {
+                    const postResult = await client.getUtils().getInactiveObjects();
+                    const postInactiveSet = new Set(postResult.objects.map((o) => `${o.type}:${o.name}`.toUpperCase()));
+                    const stillInactive = groupRefs.filter((r) => postInactiveSet.has(`${r.type}:${r.name}`.toUpperCase()));
+                    if (stillInactive.length === 0)
+                        break;
+                    if (attempt < maxRetries) {
+                        (0, logVerbose_1.logVerbose)(2, `  [*] ${stillInactive.length} still inactive, waiting... (${attempt}/${maxRetries})`);
+                        await new Promise((resolve) => setTimeout(resolve, 10000));
+                    }
+                }
+            }
+            // Report per-object status
+            const finalResult = await client.getUtils().getInactiveObjects();
+            const finalInactiveSet = new Set(finalResult.objects.map((o) => `${o.type}:${o.name}`.toUpperCase()));
+            for (const ref of groupRefs) {
+                const key = `${ref.type}:${ref.name}`.toUpperCase();
+                if (finalInactiveSet.has(key)) {
+                    (0, logVerbose_1.logVerbose)(2, `    INACTIVE ${ref.type} ${ref.name}`);
+                    failed++;
+                }
+                else {
+                    (0, logVerbose_1.logVerbose)(2, `    OK ${ref.type} ${ref.name}`);
+                    activated++;
+                }
             }
         }
-        skipped = allActions.length - activated - failed;
-        console.log(`Activation complete: ${activated} activated, ${skipped} skipped, ${failed} failed`);
+        console.log(`Activation complete: ${activated} activated, ${alreadyActive} already active, ${failed} still inactive`);
         return;
     }
     if (command === 'diff') {