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

package/dist/lib/backup/readMetadataXmlForType.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"readMetadataXmlForType.d.ts","sourceRoot":"","sources":["../../../src/lib/backup/readMetadataXmlForType.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,2BAA2B,CAAC;AAC3D,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,UAAU,CAAC;AAG9C,wBAAsB,sBAAsB,CAC1C,MAAM,EAAE,SAAS,EACjB,IAAI,EAAE,aAAa,EACnB,IAAI,EAAE,MAAM,EACZ,kBAAkB,CAAC,EAAE,MAAM,GAC1B,OAAO,CAAC,MAAM,GAAG,IAAI,GAAG,SAAS,CAAC,CAsHpC"}
+{"version":3,"file":"readMetadataXmlForType.d.ts","sourceRoot":"","sources":["../../../src/lib/backup/readMetadataXmlForType.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,2BAA2B,CAAC;AAC3D,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,UAAU,CAAC;AAG9C,wBAAsB,sBAAsB,CAC1C,MAAM,EAAE,SAAS,EACjB,IAAI,EAAE,aAAa,EACnB,IAAI,EAAE,MAAM,EACZ,kBAAkB,CAAC,EAAE,MAAM,GAC1B,OAAO,CAAC,MAAM,GAAG,IAAI,GAAG,SAAS,CAAC,CA0IpC"}

package/dist/lib/backup/readMetadataXmlForType.js

@@ -4,106 +4,126 @@ exports.readMetadataXmlForType = readMetadataXmlForType;
 const responseToText_1 = require("../utils/responseToText");
 async function readMetadataXmlForType(client, type, name, _functionGroupName) {
     try {
+        let result;
         switch (type) {
             case 'package': {
                 const state = await client
                     .getPackage()
                     .readMetadata({ packageName: name });
-                return (0, responseToText_1.responseToText)(state.metadataResult);
+                result = (0, responseToText_1.responseToText)(state.metadataResult);
+                break;
             }
             case 'class': {
                 const state = await client.getClass().readMetadata({ className: name });
-                return (0, responseToText_1.responseToText)(state.metadataResult);
+                result = (0, responseToText_1.responseToText)(state.metadataResult);
+                break;
             }
             case 'interface': {
                 const state = await client
                     .getInterface()
                     .readMetadata({ interfaceName: name });
-                return (0, responseToText_1.responseToText)(state.metadataResult);
+                result = (0, responseToText_1.responseToText)(state.metadataResult);
+                break;
             }
             case 'domain': {
                 const state = await client
                     .getDomain()
                     .readMetadata({ domainName: name });
-                return (0, responseToText_1.responseToText)(state.metadataResult);
+                result = (0, responseToText_1.responseToText)(state.metadataResult);
+                break;
             }
             case 'dataElement': {
                 const state = await client
                     .getDataElement()
                     .readMetadata({ dataElementName: name });
-                return (0, responseToText_1.responseToText)(state.metadataResult);
+                result = (0, responseToText_1.responseToText)(state.metadataResult);
+                break;
             }
             case 'table': {
                 const state = await client.getTable().readMetadata({ tableName: name });
-                return (0, responseToText_1.responseToText)(state.metadataResult);
+                result = (0, responseToText_1.responseToText)(state.metadataResult);
+                break;
             }
             case 'tableType': {
                 const state = await client
                     .getTableType()
                     .readMetadata({ tableTypeName: name });
-                return (0, responseToText_1.responseToText)(state.metadataResult);
+                result = (0, responseToText_1.responseToText)(state.metadataResult);
+                break;
             }
             case 'structure': {
                 const state = await client
                     .getStructure()
                     .readMetadata({ structureName: name });
-                return (0, responseToText_1.responseToText)(state.metadataResult);
+                result = (0, responseToText_1.responseToText)(state.metadataResult);
+                break;
             }
             case 'view': {
                 const state = await client.getView().readMetadata({ viewName: name });
-                return (0, responseToText_1.responseToText)(state.metadataResult);
+                result = (0, responseToText_1.responseToText)(state.metadataResult);
+                break;
             }
             case 'behaviorDefinition': {
                 const state = await client
                     .getBehaviorDefinition()
                     .readMetadata({ name });
-                return (0, responseToText_1.responseToText)(state.metadataResult);
+                result = (0, responseToText_1.responseToText)(state.metadataResult);
+                break;
             }
             case 'behaviorImplementation': {
                 const state = await client
                     .getBehaviorImplementation()
                     .readMetadata({ className: name });
-                return (0, responseToText_1.responseToText)(state.metadataResult);
+                result = (0, responseToText_1.responseToText)(state.metadataResult);
+                break;
             }
             case 'serviceDefinition': {
                 const state = await client
                     .getServiceDefinition()
                     .readMetadata({ serviceDefinitionName: name });
-                return (0, responseToText_1.responseToText)(state.metadataResult);
+                result = (0, responseToText_1.responseToText)(state.metadataResult);
+                break;
             }
             case 'serviceBinding': {
                 const state = await client
                     .getServiceBinding()
                     .readMetadata({ bindingName: name });
-                return (0, responseToText_1.responseToText)(state.metadataResult);
+                result = (0, responseToText_1.responseToText)(state.metadataResult);
+                break;
             }
             case 'metadataExtension': {
                 const state = await client
                     .getMetadataExtension()
                     .readMetadata({ name });
-                return (0, responseToText_1.responseToText)(state.metadataResult);
+                result = (0, responseToText_1.responseToText)(state.metadataResult);
+                break;
             }
             case 'functionGroup': {
                 const state = await client
                     .getFunctionGroup()
                     .readMetadata({ functionGroupName: name });
-                return (0, responseToText_1.responseToText)(state.metadataResult);
+                result = (0, responseToText_1.responseToText)(state.metadataResult);
+                break;
             }
             case 'enhancement': {
                 const state = await client
                     .getEnhancement()
                     .readMetadata({ enhancementName: name, enhancementType: 'enhoxh' });
-                return (0, responseToText_1.responseToText)(state.metadataResult);
+                result = (0, responseToText_1.responseToText)(state.metadataResult);
+                break;
             }
             case 'accessControl': {
                 const state = await client
                     .getAccessControl()
                     .readMetadata({ accessControlName: name });
-                return (0, responseToText_1.responseToText)(state.metadataResult);
+                result = (0, responseToText_1.responseToText)(state.metadataResult);
+                break;
             }
             default:
                 return undefined;
         }
+        // ADT clients return undefined on 404 — treat as not found
+        return result ?? null;
     }
     catch (error) {
         const status = error.status || error.response?.status;

package/dist/lib/restore/analyzeDependencies.d.ts

@@ -10,4 +10,10 @@ export interface RestoreGroup {
  * (e.g. view and behaviorDefinition for the same CDS entity).
  */
 export declare function analyzeDependencies(nodes: BackupTreeNode[]): RestoreGroup[];
+/**
+ * Analyzes dependencies and merges SCCs at the same dependency level
+ * into single groups. Level = max(level of dependencies) + 1.
+ * Independent SCCs (same level) are merged into one group.
+ */
+export declare function analyzeDependencyLevels(nodes: BackupTreeNode[]): RestoreGroup[];
 //# sourceMappingURL=analyzeDependencies.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"analyzeDependencies.d.ts","sourceRoot":"","sources":["../../../src/lib/restore/analyzeDependencies.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,UAAU,CAAC;AAE/C,MAAM,WAAW,YAAY;IAC3B,KAAK,EAAE,cAAc,EAAE,CAAC;IACxB,UAAU,EAAE,OAAO,CAAC;CACrB;AAMD;;;;;GAKG;AACH,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,cAAc,EAAE,GAAG,YAAY,EAAE,CAwM3E"}
+{"version":3,"file":"analyzeDependencies.d.ts","sourceRoot":"","sources":["../../../src/lib/restore/analyzeDependencies.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,UAAU,CAAC;AAE/C,MAAM,WAAW,YAAY;IAC3B,KAAK,EAAE,cAAc,EAAE,CAAC;IACxB,UAAU,EAAE,OAAO,CAAC;CACrB;AA+MD;;;;;GAKG;AACH,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,cAAc,EAAE,GAAG,YAAY,EAAE,CA2B3E;AA2BD;;;;GAIG;AACH,wBAAgB,uBAAuB,CACrC,KAAK,EAAE,cAAc,EAAE,GACtB,YAAY,EAAE,CA8DhB"}

package/dist/lib/restore/analyzeDependencies.js

@@ -1,30 +1,15 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.analyzeDependencies = analyzeDependencies;
+exports.analyzeDependencyLevels = analyzeDependencyLevels;
 const decodeBase64_1 = require("../crypto/decodeBase64");
 function nodeKey(node) {
     return `${node.type}:${node.name}`.toUpperCase();
 }
 /**
- * Robustly analyzes dependencies between objects by scanning both
- * source code and XML metadata.
- * Uses composite type:name keys to handle objects that share the same name
- * (e.g. view and behaviorDefinition for the same CDS entity).
+ * Build adjacency map (forward dependencies) by scanning source code and config.
  */
-function analyzeDependencies(nodes) {
-    const idToNode = new Map();
-    const nameToIds = new Map();
-    const allNames = new Set();
-    for (const node of nodes) {
-        const id = nodeKey(node);
-        const upperName = node.name.toUpperCase();
-        idToNode.set(id, node);
-        allNames.add(upperName);
-        const ids = nameToIds.get(upperName) || [];
-        ids.push(id);
-        nameToIds.set(upperName, ids);
-    }
-    const allIds = new Set(idToNode.keys());
+function buildAdjacency(nodes, allNames, nameToIds, allIds) {
     const adj = new Map();
     for (const node of nodes) {
         const deps = new Set();
@@ -37,13 +22,9 @@ function analyzeDependencies(nodes) {
             for (const targetName of allNames) {
                 if (targetName === nodeNameUpper)
                     continue;
-                // Escape name for regex, specifically handling namespaces with /
                 const escapedTarget = targetName.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
-                // Match only if surrounded by boundaries that are NOT part of an ABAP name
-                // (i.e. not letters, digits, _, or /)
                 const regex = new RegExp(`(?<=[^A-Z0-9_/]|^)${escapedTarget}(?=[^A-Z0-9_/]|$)`, 'g');
                 if (regex.test(contentUpper)) {
-                    // Resolve name to all node IDs with that name
                     const targetIds = nameToIds.get(targetName) || [];
                     for (const tid of targetIds) {
                         if (tid !== id)
@@ -51,9 +32,8 @@ function analyzeDependencies(nodes) {
                     }
                 }
             }
-            // 2. Explicit structural dependencies (from config or XML properties)
-            // Behavior Definition <-> Implementation Class (bidirectional = same SCC group)
-            // From class source: "FOR BEHAVIOR OF <bdef_name>"
+            // 2. Explicit structural dependencies
+            // BIML class -> BDEF (bidirectional = same SCC)
             if (node.type === 'class' || node.type === 'behaviorImplementation') {
                 const bdefMatch = contentUpper.match(/FOR\s+BEHAVIOR\s+OF\s+([A-Z0-9_/]+)/);
                 if (bdefMatch) {
@@ -62,7 +42,7 @@ function analyzeDependencies(nodes) {
                         deps.add(bdefId);
                 }
             }
-            // From BDEF source: "IMPLEMENTATION IN CLASS <class_name>"
+            // BDEF -> BIML class
             if (node.type === 'behaviorDefinition') {
                 for (const m of contentUpper.matchAll(/IMPLEMENTATION\s+IN\s+CLASS\s+([A-Z0-9_/]+)/g)) {
                     const className = m[1];
@@ -93,7 +73,12 @@ function analyzeDependencies(nodes) {
         }
         adj.set(id, deps);
     }
-    // Tarjan's algorithm for SCCs
+    return adj;
+}
+/**
+ * Tarjan's SCC algorithm.
+ */
+function tarjanSCC(allIds, adj) {
     let index = 0;
     const stack = [];
     const onStack = new Set();
@@ -140,7 +125,12 @@ function analyzeDependencies(nodes) {
             strongConnect(id);
         }
     }
-    // Dependency graph of SCCs
+    return sccs;
+}
+/**
+ * Build SCC DAG and topological order from SCCs and adjacency map.
+ */
+function buildSccDag(sccs, adj) {
     const sccAdj = new Map();
     const nodeToSccIndex = new Map();
     sccs.forEach((scc, i) => {
@@ -177,6 +167,31 @@ function analyzeDependencies(nodes) {
     for (let i = 0; i < sccs.length; i++) {
         visit(i);
     }
+    return { sccAdj, order };
+}
+/**
+ * Robustly analyzes dependencies between objects by scanning both
+ * source code and XML metadata.
+ * Uses composite type:name keys to handle objects that share the same name
+ * (e.g. view and behaviorDefinition for the same CDS entity).
+ */
+function analyzeDependencies(nodes) {
+    const idToNode = new Map();
+    const nameToIds = new Map();
+    const allNames = new Set();
+    for (const node of nodes) {
+        const id = nodeKey(node);
+        const upperName = node.name.toUpperCase();
+        idToNode.set(id, node);
+        allNames.add(upperName);
+        const ids = nameToIds.get(upperName) || [];
+        ids.push(id);
+        nameToIds.set(upperName, ids);
+    }
+    const allIds = new Set(idToNode.keys());
+    const adj = buildAdjacency(nodes, allNames, nameToIds, allIds);
+    const sccs = tarjanSCC(allIds, adj);
+    const { order } = buildSccDag(sccs, adj);
     return order.map((i) => {
         const ids = sccs[i];
         return {
@@ -185,3 +200,86 @@ function analyzeDependencies(nodes) {
         };
     });
 }
+/**
+ * Creation order priority within a group.
+ * Lower = created first. Ensures BDEF exists before BIML class, etc.
+ */
+const TYPE_CREATION_ORDER = {
+    domain: 0,
+    dataElement: 1,
+    structure: 2,
+    table: 2,
+    tableType: 2,
+    view: 3,
+    behaviorDefinition: 4,
+    behaviorImplementation: 5,
+    class: 5,
+    interface: 5,
+    accessControl: 6,
+    metadataExtension: 6,
+    program: 7,
+    functionGroup: 7,
+    functionModule: 8,
+    serviceDefinition: 9,
+    serviceBinding: 10,
+    enhancement: 11,
+};
+/**
+ * Analyzes dependencies and merges SCCs at the same dependency level
+ * into single groups. Level = max(level of dependencies) + 1.
+ * Independent SCCs (same level) are merged into one group.
+ */
+function analyzeDependencyLevels(nodes) {
+    const idToNode = new Map();
+    const nameToIds = new Map();
+    const allNames = new Set();
+    for (const node of nodes) {
+        const id = nodeKey(node);
+        const upperName = node.name.toUpperCase();
+        idToNode.set(id, node);
+        allNames.add(upperName);
+        const ids = nameToIds.get(upperName) || [];
+        ids.push(id);
+        nameToIds.set(upperName, ids);
+    }
+    const allIds = new Set(idToNode.keys());
+    const adj = buildAdjacency(nodes, allNames, nameToIds, allIds);
+    const sccs = tarjanSCC(allIds, adj);
+    const { sccAdj, order } = buildSccDag(sccs, adj);
+    // Compute level for each SCC: level = max(level of deps) + 1
+    const sccLevel = new Map();
+    for (const i of order) {
+        let maxDepLevel = -1;
+        const deps = sccAdj.get(i) || new Set();
+        for (const d of deps) {
+            const depLevel = sccLevel.get(d) ?? 0;
+            if (depLevel > maxDepLevel)
+                maxDepLevel = depLevel;
+        }
+        sccLevel.set(i, maxDepLevel + 1);
+    }
+    // Group SCCs by level, merge into RestoreGroups
+    const levelMap = new Map();
+    for (const i of order) {
+        const level = sccLevel.get(i);
+        if (!levelMap.has(level)) {
+            levelMap.set(level, { nodes: [], hasCircular: false });
+        }
+        const entry = levelMap.get(level);
+        const sccNodes = sccs[i].map((id) => idToNode.get(id));
+        entry.nodes.push(...sccNodes);
+        if (sccs[i].length > 1)
+            entry.hasCircular = true;
+    }
+    const sortedLevels = [...levelMap.keys()].sort((a, b) => a - b);
+    return sortedLevels.map((level) => {
+        const entry = levelMap.get(level);
+        // Sort nodes within group by creation order (views before BDEFs before classes)
+        entry.nodes.sort((a, b) => (TYPE_CREATION_ORDER[a.type || ''] ?? 99) -
+            (TYPE_CREATION_ORDER[b.type || ''] ?? 99));
+        return {
+            nodes: entry.nodes,
+            isCircular: entry.hasCircular || entry.nodes.length > 1,
+        };
+    });
+}

package/dist/lib/restore/restoreTreeBackup.d.ts

@@ -1,4 +1,4 @@
 import type { AdtClient } from '@mcp-abap-adt/adt-clients';
-import type { BackupTreeNode, RestoreMode } from '../types';
-export declare function restoreTreeBackup(client: AdtClient, root: BackupTreeNode, mode: RestoreMode, activate: boolean, transportRequest?: string, restoreIds?: Set<string>, restoreActions?: Map<string, RestoreMode>, activateOnCreate?: boolean, softwareComponent?: string, superPackageOverride?: string, transportLayer?: string): Promise<void>;
+import type { BackupTreeNode, RestoreMode, RestorePlanGroup } from '../types';
+export declare function restoreTreeBackup(client: AdtClient, root: BackupTreeNode, mode: RestoreMode, activate: boolean, transportRequest?: string, restoreIds?: Set<string>, planGroups?: RestorePlanGroup[], activateOnCreate?: boolean, softwareComponent?: string, superPackageOverride?: string, transportLayer?: string): Promise<void>;
 //# sourceMappingURL=restoreTreeBackup.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"restoreTreeBackup.d.ts","sourceRoot":"","sources":["../../../src/lib/restore/restoreTreeBackup.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAmB,MAAM,2BAA2B,CAAC;AAI5E,OAAO,KAAK,EAAE,cAAc,EAAE,WAAW,EAAiB,MAAM,UAAU,CAAC;AAwD3E,wBAAsB,iBAAiB,CACrC,MAAM,EAAE,SAAS,EACjB,IAAI,EAAE,cAAc,EACpB,IAAI,EAAE,WAAW,EACjB,QAAQ,EAAE,OAAO,EACjB,gBAAgB,CAAC,EAAE,MAAM,EACzB,UAAU,CAAC,EAAE,GAAG,CAAC,MAAM,CAAC,EACxB,cAAc,CAAC,EAAE,GAAG,CAAC,MAAM,EAAE,WAAW,CAAC,EACzC,gBAAgB,UAAO,EACvB,iBAAiB,CAAC,EAAE,MAAM,EAC1B,oBAAoB,CAAC,EAAE,MAAM,EAC7B,cAAc,CAAC,EAAE,MAAM,GACtB,OAAO,CAAC,IAAI,CAAC,CA2Pf"}
+{"version":3,"file":"restoreTreeBackup.d.ts","sourceRoot":"","sources":["../../../src/lib/restore/restoreTreeBackup.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAmB,MAAM,2BAA2B,CAAC;AAK5E,OAAO,KAAK,EACV,cAAc,EACd,WAAW,EACX,gBAAgB,EAEjB,MAAM,UAAU,CAAC;AA8DlB,wBAAsB,iBAAiB,CACrC,MAAM,EAAE,SAAS,EACjB,IAAI,EAAE,cAAc,EACpB,IAAI,EAAE,WAAW,EACjB,QAAQ,EAAE,OAAO,EACjB,gBAAgB,CAAC,EAAE,MAAM,EACzB,UAAU,CAAC,EAAE,GAAG,CAAC,MAAM,CAAC,EACxB,UAAU,CAAC,EAAE,gBAAgB,EAAE,EAC/B,gBAAgB,UAAO,EACvB,iBAAiB,CAAC,EAAE,MAAM,EAC1B,oBAAoB,CAAC,EAAE,MAAM,EAC7B,cAAc,CAAC,EAAE,MAAM,GACtB,OAAO,CAAC,IAAI,CAAC,CAiZf"}

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' },
@@ -45,7 +51,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 +63,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 +180,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);
+            }
+            if (groupRefs.length > 0) {
+                await bulkActivate(`Group ${group.id}${group.isCircular ? ' (circular)' : ''}`, groupRefs);
             }
-            await bulkActivate(phase.name, refs);
-            allProcessedRefs.push(...refs);
+            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/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') {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mcp-abap-adt/adt-backup",
-  "version": "1.1.0",
+  "version": "1.2.0",
   "description": "ADT backup CLI for SAP ABAP objects (recursive package backups and restores)",
   "main": "dist/bin/adt-backup.js",
   "types": "dist/bin/adt-backup.d.ts",