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

package/dist/lib/run.js

@@ -51,7 +51,6 @@ const createLogger_1 = require("./cli/createLogger");
 const getVerbosity_1 = require("./cli/getVerbosity");
 const logVerbose_1 = require("./cli/logVerbose");
 const parseArgs_1 = require("./cli/parseArgs");
-const redact_1 = require("./cli/redact");
 const shouldEnableAdtLogger_1 = require("./cli/shouldEnableAdtLogger");
 const shouldEnableConnectionLogger_1 = require("./cli/shouldEnableConnectionLogger");
 const usage_1 = require("./cli/usage");
@@ -62,31 +61,28 @@ const encodeBase64_1 = require("./crypto/encodeBase64");
 const updateTreeChecksums_1 = require("./crypto/updateTreeChecksums");
 const verifyBackupChecksum_1 = require("./crypto/verifyBackupChecksum");
 const verifyTreeChecksums_1 = require("./crypto/verifyTreeChecksums");
-const buildRestorePlan_1 = require("./restore/buildRestorePlan");
-const deleteBackupObjects_1 = require("./restore/deleteBackupObjects");
-const restoreObjects_1 = require("./restore/restoreObjects");
+const collectTreeDependencies_1 = require("./dependencies/collectTreeDependencies");
+const analyzeDependencies_1 = require("./restore/analyzeDependencies");
 const restoreTreeBackup_1 = require("./restore/restoreTreeBackup");
 const verbosity_1 = require("./state/verbosity");
 const buildPackageBackupTree_1 = require("./tree/buildPackageBackupTree");
-const buildTreeList_1 = require("./tree/buildTreeList");
-const collectTreeObjects_1 = require("./tree/collectTreeObjects");
+const enrichTreeNode_1 = require("./tree/enrichTreeNode");
 const findNodeInTree_1 = require("./tree/findNodeInTree");
-const formatTreeListText_1 = require("./tree/formatTreeListText");
-const getNodeObjectSpec_1 = require("./tree/getNodeObjectSpec");
+const flattenTree_1 = require("./tree/flattenTree");
+const getNodeObjectId_1 = require("./tree/getNodeObjectId");
 const diffUnified_1 = require("./utils/diffUnified");
 const formatObjectSpec_1 = require("./utils/formatObjectSpec");
 const parseObjectSpec_1 = require("./utils/parseObjectSpec");
-const collectBackupNodes_1 = require("./verify/collectBackupNodes");
-const findOtherType_1 = require("./verify/findOtherType");
 const formatVerifyResultsText_1 = require("./verify/formatVerifyResultsText");
 const verifyBackup_1 = require("./verify/verifyBackup");
 const extractMetadata_1 = require("./xml/extractMetadata");
 async function run() {
     const argv = process.argv.slice(2);
-    verbosity_1.verbosityState.level = (0, getVerbosity_1.getVerbosity)(argv);
+    const args = (0, parseArgs_1.parseArgs)(argv.slice(1));
+    verbosity_1.verbosityState.level =
+        typeof args.verbosity === 'number' ? args.verbosity : (0, getVerbosity_1.getVerbosity)(argv);
     const logger = (0, createLogger_1.createLogger)(verbosity_1.verbosityState.level);
     const command = argv[0];
-    const args = (0, parseArgs_1.parseArgs)(argv.slice(1));
     const logFile = typeof args['log-file'] === 'string' ? args['log-file'] : '';
     if (logFile) {
         enableLogFile(logFile);
@@ -110,639 +106,486 @@ async function run() {
         console.log((0, usage_1.usage)(helpCommand));
         process.exit(0);
     }
-    if (command === 'extract') {
-        const input = args.input;
-        const objectSpec = args.object;
-        const output = args.out;
-        if (typeof input !== 'string') {
-            throw new Error('Missing --input');
-        }
-        if (typeof objectSpec !== 'string') {
-            throw new Error('Missing --object');
-        }
-        if (typeof output !== 'string') {
-            throw new Error('Missing --out');
-        }
-        (0, logVerbose_1.logVerbose)(2, `Extracting ${objectSpec} from ${input}`);
-        const raw = fs.readFileSync(input, 'utf8');
-        const parsed = yaml_1.default.parse(raw);
-        if (!parsed || parsed.schemaVersion !== 2) {
-            throw new Error('Extract supports only schemaVersion 2 backups');
-        }
-        (0, verifyBackupChecksum_1.verifyBackupChecksum)(parsed);
-        (0, verifyTreeChecksums_1.verifyTreeChecksums)(parsed.root);
-        const spec = (0, parseObjectSpec_1.parseObjectSpec)(objectSpec);
-        (0, logVerbose_1.logVerbose)(3, `Parsed object spec: ${spec.type}:${spec.name}`);
-        const node = (0, findNodeInTree_1.findNodeInTree)(parsed.root, spec);
-        if (!node || !node.codeBase64) {
-            throw new Error('Object not found or no codeBase64 in backup');
-        }
-        fs.writeFileSync(output, (0, decodeBase64_1.decodeBase64)(node.codeBase64), 'utf8');
-        console.log(`Extracted to ${output}`);
-        return;
+    const isMcp = Boolean(args.mcp);
+    const isEnv = Boolean(args.env);
+    const envPathArg = typeof args['env-path'] === 'string' ? args['env-path'] : undefined;
+    let destination;
+    let envPath;
+    if (envPathArg) {
+        envPath = envPathArg;
+        destination = 'env';
     }
-    if (command === 'list') {
-        const input = args.input;
-        if (typeof input !== 'string') {
-            throw new Error('Missing --input');
-        }
-        const format = typeof args.format === 'string' ? args.format : 'text';
-        const flat = Boolean(args.flat);
-        const showDeps = Boolean(args.deps);
-        const raw = fs.readFileSync(input, 'utf8');
-        const parsed = yaml_1.default.parse(raw);
-        if (!parsed || typeof parsed !== 'object') {
-            throw new Error('Invalid backup file format');
-        }
-        if (parsed.schemaVersion === 2) {
-            const tree = parsed;
-            if (flat) {
-                const objects = [];
-                (0, collectTreeObjects_1.collectTreeObjects)(tree.root, objects);
-                if (format === 'json') {
-                    console.log(JSON.stringify(objects, null, 2));
-                }
-                else {
-                    for (const spec of objects) {
-                        console.log((0, formatObjectSpec_1.formatObjectSpec)(spec));
-                    }
-                }
-                return;
-            }
-            if (format === 'json') {
-                console.log(JSON.stringify((0, buildTreeList_1.buildTreeList)(tree.root, { showDeps }), null, 2));
-            }
-            else {
-                const lines = (0, formatTreeListText_1.formatTreeListText)(tree.root, 0, { showDeps });
-                console.log(lines.join('\n'));
-            }
-            return;
-        }
-        if (parsed.schemaVersion === 1) {
-            const flat = parsed;
-            const objects = flat.objects.map((obj) => ({
-                type: obj.type,
-                name: obj.name,
-                functionGroupName: obj.functionGroupName,
-            }));
-            if (format === 'json') {
-                console.log(JSON.stringify(objects, null, 2));
-            }
-            else {
-                for (const spec of objects) {
-                    console.log((0, formatObjectSpec_1.formatObjectSpec)(spec));
-                }
-            }
-            return;
-        }
-        throw new Error('Invalid backup file format');
+    else if (isEnv) {
+        destination = 'env';
     }
-    if (command === 'patch') {
-        const input = args.input;
-        const objectSpec = args.object;
-        const filePath = args.file;
-        if (typeof input !== 'string') {
-            throw new Error('Missing --input');
-        }
-        if (typeof objectSpec !== 'string') {
-            throw new Error('Missing --object');
-        }
-        if (typeof filePath !== 'string') {
-            throw new Error('Missing --file');
-        }
-        const output = typeof args.output === 'string' ? args.output : input;
-        (0, logVerbose_1.logVerbose)(2, `Patching ${objectSpec} in ${input}`);
-        const raw = fs.readFileSync(input, 'utf8');
-        const parsed = yaml_1.default.parse(raw);
-        if (!parsed || parsed.schemaVersion !== 2) {
-            throw new Error('Patch supports only schemaVersion 2 backups');
-        }
-        (0, verifyBackupChecksum_1.verifyBackupChecksum)(parsed);
-        (0, verifyTreeChecksums_1.verifyTreeChecksums)(parsed.root);
-        const spec = (0, parseObjectSpec_1.parseObjectSpec)(objectSpec);
-        (0, logVerbose_1.logVerbose)(3, `Parsed object spec: ${spec.type}:${spec.name}`);
-        const node = (0, findNodeInTree_1.findNodeInTree)(parsed.root, spec);
-        if (!node) {
-            throw new Error('Object not found in backup');
-        }
-        const fileContent = fs.readFileSync(filePath, 'utf8');
-        node.codeBase64 = (0, encodeBase64_1.encodeBase64)(fileContent);
-        node.codeChecksum = undefined;
-        node.restoreStatus = 'ok';
-        if (!node.codeFormat) {
-            node.codeFormat = 'source';
-        }
-        (0, updateTreeChecksums_1.updateTreeChecksums)(parsed.root);
-        parsed.checksum = (0, computeBackupChecksum_1.computeBackupChecksum)(parsed);
-        const yamlText = yaml_1.default.stringify(parsed, { lineWidth: 0 });
-        fs.writeFileSync(output, yamlText, 'utf8');
-        console.log(`Backup updated at ${output}`);
-        return;
+    else if (isMcp) {
+        destination = 'SAP';
     }
-    if (command === 'validate') {
-        const input = args.input;
-        const objectSpec = args.object;
-        if (typeof input !== 'string') {
-            throw new Error('Missing --input');
-        }
-        const raw = fs.readFileSync(input, 'utf8');
-        const parsed = yaml_1.default.parse(raw);
-        if (!parsed || typeof parsed !== 'object') {
-            throw new Error('Invalid backup file format');
-        }
-        (0, verifyBackupChecksum_1.verifyBackupChecksum)(parsed);
-        if (parsed.schemaVersion === 2) {
-            const tree = parsed;
-            if (typeof objectSpec === 'string') {
-                const spec = (0, parseObjectSpec_1.parseObjectSpec)(objectSpec);
-                const node = (0, findNodeInTree_1.findNodeInTree)(tree.root, spec);
-                if (!node) {
-                    throw new Error(`Object not found: ${(0, formatObjectSpec_1.formatObjectSpec)(spec)}`);
-                }
-                if (!node.codeBase64) {
-                    throw new Error('Object has no codeBase64 to validate');
-                }
-                if (!node.codeChecksum) {
-                    throw new Error('Object has no codeChecksum to validate');
-                }
-                const expected = (0, computeCodeChecksum_1.computeCodeChecksum)(node.codeBase64);
-                if (expected !== node.codeChecksum) {
-                    throw new Error('Object code checksum mismatch');
-                }
-                console.log(`Validated object ${(0, formatObjectSpec_1.formatObjectSpec)(spec)}`);
-            }
-            else {
-                (0, verifyTreeChecksums_1.verifyTreeChecksums)(tree.root);
-                console.log('Backup validated');
-            }
-            return;
-        }
-        if (parsed.schemaVersion === 1) {
-            if (typeof objectSpec === 'string') {
-                const spec = (0, parseObjectSpec_1.parseObjectSpec)(objectSpec);
-                const flat = parsed;
-                const matches = flat.objects.some((obj) => obj.type === spec.type &&
-                    obj.name === spec.name &&
-                    (spec.functionGroupName
-                        ? obj.functionGroupName === spec.functionGroupName
-                        : true));
-                if (!matches) {
-                    throw new Error(`Object not found: ${(0, formatObjectSpec_1.formatObjectSpec)(spec)}`);
-                }
-                console.log(`Validated object ${(0, formatObjectSpec_1.formatObjectSpec)(spec)}`);
-            }
-            else {
-                console.log('Backup validated');
-            }
-            return;
+    else {
+        destination =
+            typeof args.destination === 'string'
+                ? args.destination
+                : typeof args.target === 'string'
+                    ? args.target
+                    : undefined;
+    }
+    // Authentication logic
+    const needsAuth = [
+        'tree',
+        'enrich',
+        'backup',
+        'diff',
+        'check',
+        'verify',
+        'restore',
+        'activate',
+    ].includes(command);
+    const canUseAuth = command === 'plan';
+    let client;
+    if (needsAuth || (canUseAuth && (envPath || destination))) {
+        if (needsAuth && !envPath && !destination) {
+            throw new Error(`Command "${command}" requires a TARGET system. Provide --target, --env or --env-path.`);
+        }
+        if (envPath || destination) {
+            (0, logVerbose_1.logVerbose)(1, `Connecting to system: ${destination || envPath}...`);
+            const sapAuth = await (0, getSapConfigFromBroker_1.getSapConfigFromBroker)({
+                destination,
+                envPath,
+                authRoot: typeof args['auth-root'] === 'string' ? args['auth-root'] : undefined,
+                browserAuthPort: typeof args['browser-auth-port'] === 'string'
+                    ? Number.parseInt(args['browser-auth-port'], 10)
+                    : 10001,
+                logger,
+            });
+            const allowAdtLogs = verbosity_1.verbosityState.level >= 3 || Boolean(args['debug-adt']);
+            const allowConnectionLogs = verbosity_1.verbosityState.level >= 3 || Boolean(args['debug-adt']);
+            const connectionLogger = allowConnectionLogs && (0, shouldEnableConnectionLogger_1.shouldEnableConnectionLogger)()
+                ? logger
+                : undefined;
+            const adtLogger = command !== 'verify' &&
+                command !== 'restore' &&
+                allowAdtLogs &&
+                (0, shouldEnableAdtLogger_1.shouldEnableAdtLogger)()
+                ? logger
+                : undefined;
+            const connection = (0, connection_1.createAbapConnection)(sapAuth.config, connectionLogger, undefined, sapAuth.tokenRefresher);
+            // Resolve masterSystem/responsible for AdtClient:
+            // Cloud (BTP): both from getSystemInformation endpoint
+            // On-premise: responsible from connection username, no masterSystem
+            const systemInfo = await (0, adt_clients_1.getSystemInformation)(connection);
+            const masterSystem = systemInfo?.systemID;
+            const responsible = systemInfo?.userName || sapAuth.config.username;
+            client = new adt_clients_1.AdtClient(connection, adtLogger, {
+                masterSystem,
+                responsible,
+            });
         }
-        throw new Error('Invalid backup file format');
     }
-    const envPath = typeof args.env === 'string'
-        ? args.env
-        : typeof args.config === 'string'
-            ? args.config
-            : undefined;
-    const destination = typeof args.destination === 'string' ? args.destination : undefined;
-    const authRoot = typeof args['auth-root'] === 'string' ? args['auth-root'] : undefined;
-    if (!envPath && !destination) {
-        throw new Error('Missing --destination (or provide --env)');
+    if (command === 'tree') {
+        if (!client)
+            throw new Error('Client required');
+        const packageName = typeof args.package === 'string' ? args.package : undefined;
+        if (!packageName)
+            throw new Error('Missing --package');
+        const output = typeof args.output === 'string' ? args.output : 'tree.yaml';
+        (0, logVerbose_1.logVerbose)(1, `Fetching package hierarchy for ${packageName}`);
+        const hierarchy = await client
+            .getUtils()
+            .getPackageHierarchy(packageName.toUpperCase());
+        const rootTree = { ...hierarchy, restoreStatus: 'ok' };
+        const enrichedRoot = await (0, enrichTreeNode_1.enrichTreeNode)(rootTree, client, false);
+        await (0, collectTreeDependencies_1.collectTreeDependencies)(client, enrichedRoot);
+        const payload = {
+            schemaVersion: 2,
+            generatedAt: new Date().toISOString(),
+            package: packageName.toUpperCase(),
+            root: enrichedRoot,
+        };
+        payload.checksum = (0, computeBackupChecksum_1.computeBackupChecksum)(payload);
+        fs.writeFileSync(output, yaml_1.default.stringify(payload, { lineWidth: 0 }), 'utf8');
+        console.log(`Tree written to ${output}`);
+        console.log(`Next step: adt-backup enrich --input ${output} --output backup.yaml --target ${destination || '<sys>'}`);
+        return;
     }
-    const { config, tokenRefresher } = await (0, getSapConfigFromBroker_1.getSapConfigFromBroker)({
-        destination,
-        envPath,
-        authRoot,
-        logger,
-    });
-    const allowAdtLogs = verbosity_1.verbosityState.level >= 2 || debugAdt;
-    const allowConnectionLogs = verbosity_1.verbosityState.level >= 3 || debugAdt;
-    const connectionLogger = allowConnectionLogs && (0, shouldEnableConnectionLogger_1.shouldEnableConnectionLogger)() ? logger : undefined;
-    const adtLogger = allowAdtLogs && (0, shouldEnableAdtLogger_1.shouldEnableAdtLogger)() ? logger : undefined;
-    const connection = (0, connection_1.createAbapConnection)(config, connectionLogger, undefined, tokenRefresher);
-    const client = new adt_clients_1.AdtClient(connection, adtLogger);
     if (command === 'backup') {
-        const rawObjects = args.objects;
+        if (!client)
+            throw new Error('Client required');
         const packageName = typeof args.package === 'string' ? args.package : undefined;
+        const rawObjects = args.objects;
+        const output = typeof args.output === 'string' ? args.output : 'backup.yaml';
         if (packageName) {
-            (0, logVerbose_1.logVerbose)(2, `Starting package backup for ${packageName}`);
-            const output = typeof args.output === 'string' ? args.output : 'backup.yaml';
             const tree = await (0, buildPackageBackupTree_1.buildPackageBackupTree)(client, packageName);
             (0, updateTreeChecksums_1.updateTreeChecksums)(tree.root);
             tree.checksum = (0, computeBackupChecksum_1.computeBackupChecksum)(tree);
-            const yamlText = yaml_1.default.stringify(tree, { lineWidth: 0 });
-            fs.writeFileSync(output, yamlText, 'utf8');
+            fs.writeFileSync(output, yaml_1.default.stringify(tree, { lineWidth: 0 }), 'utf8');
             console.log(`Backup written to ${output}`);
+            console.log(`Next step: adt-backup plan --input ${output} --output plan.yaml`);
             return;
         }
-        if (typeof rawObjects !== 'string') {
+        if (typeof rawObjects !== 'string')
             throw new Error('Missing --objects or --package');
-        }
-        (0, logVerbose_1.logVerbose)(2, `Starting objects backup (${rawObjects})`);
         const specs = rawObjects
             .split(',')
-            .map((spec) => spec.trim())
+            .map((s) => s.trim())
             .filter(Boolean)
             .map(parseObjectSpec_1.parseObjectSpec);
         const objects = [];
         for (const spec of specs) {
-            (0, logVerbose_1.logVerbose)(3, `Backup ${spec.type}:${spec.name}`);
-            const backup = await (0, backupObject_1.backupObject)(client, spec);
-            objects.push(backup);
+            objects.push(await (0, backupObject_1.backupObject)(client, spec));
         }
-        const output = typeof args.output === 'string' ? args.output : 'backup.yaml';
         const payload = {
             schemaVersion: 1,
             generatedAt: new Date().toISOString(),
             objects,
         };
         payload.checksum = (0, computeBackupChecksum_1.computeBackupChecksum)(payload);
-        const yamlText = yaml_1.default.stringify(payload, { lineWidth: 0 });
-        fs.writeFileSync(output, yamlText, 'utf8');
+        fs.writeFileSync(output, yaml_1.default.stringify(payload, { lineWidth: 0 }), 'utf8');
         console.log(`Backup written to ${output}`);
         return;
     }
+    if (command === 'enrich') {
+        if (!client)
+            throw new Error('Client required');
+        const input = args.input;
+        if (typeof input !== 'string')
+            throw new Error('Missing --input');
+        const output = typeof args.output === 'string' ? args.output : input;
+        const backup = yaml_1.default.parse(fs.readFileSync(input, 'utf8'));
+        backup.root = await (0, enrichTreeNode_1.enrichTreeNode)(backup.root, client, true);
+        (0, updateTreeChecksums_1.updateTreeChecksums)(backup.root);
+        backup.checksum = (0, computeBackupChecksum_1.computeBackupChecksum)(backup);
+        fs.writeFileSync(output, yaml_1.default.stringify(backup, { lineWidth: 0 }), 'utf8');
+        console.log(`Enriched backup written to ${output}`);
+        console.log(`Next step: adt-backup plan --input ${output} --output plan.yaml`);
+        return;
+    }
+    if (command === 'plan') {
+        const input = args.input;
+        if (typeof input !== 'string')
+            throw new Error('Missing --input');
+        const output = typeof args.output === 'string' ? args.output : 'plan.yaml';
+        const mode = args.mode || 'create';
+        (0, logVerbose_1.logVerbose)(1, `Planning restoration from ${input} (offline)...`);
+        const backup = yaml_1.default.parse(fs.readFileSync(input, 'utf8'));
+        if (!backup || backup.schemaVersion !== 2)
+            throw new Error('SchemaVersion 2 required');
+        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);
+        const plan = {
+            schemaVersion: 1,
+            generatedAt: new Date().toISOString(),
+            backupFile: path.resolve(input),
+            targetPackage: backup.package,
+            groups: [
+                {
+                    id: 0,
+                    isCircular: false,
+                    actions: packageNodes.map((node) => ({
+                        id: (0, getNodeObjectId_1.getNodeObjectId)(node),
+                        type: node.type,
+                        name: node.name,
+                        action: mode,
+                        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,
+                    })),
+                })),
+            ],
+        };
+        fs.writeFileSync(output, yaml_1.default.stringify(plan, { lineWidth: 0 }), 'utf8');
+        console.log(`Plan written to ${output}`);
+        console.log(`Next step: adt-backup verify --plan ${output} --target ${destination || '<sys>'}`);
+        return;
+    }
+    if (command === 'verify') {
+        if (!client)
+            throw new Error('Client required');
+        const planPath = args.plan;
+        if (!planPath || typeof planPath !== 'string')
+            throw new Error('Missing --plan');
+        const output = typeof args.output === 'string' ? args.output : planPath;
+        const plan = yaml_1.default.parse(fs.readFileSync(planPath, 'utf8'));
+        const backup = yaml_1.default.parse(fs.readFileSync(plan.backupFile, 'utf8'));
+        const verifyResult = await (0, verifyBackup_1.verifyBackup)(client, backup, {
+            mode: 'pre-restore',
+        });
+        const systemState = new Map();
+        for (const entry of verifyResult.entries) {
+            systemState.set(`${entry.type}:${entry.name}`, entry.status);
+        }
+        const skipExisting = Boolean(args['skip-existing']);
+        const skipUnchanged = Boolean(args['skip-unchanged']);
+        for (const group of plan.groups) {
+            for (const action of group.actions) {
+                const id = `${action.type}:${action.name}`;
+                const status = systemState.get(id);
+                if (status === 'ok') {
+                    action.action = skipExisting || skipUnchanged ? 'skip' : 'update';
+                }
+                else if (status === 'package-mismatch' ||
+                    status === 'source-mismatch') {
+                    action.action = skipExisting ? 'skip' : 'update';
+                }
+                else {
+                    action.action = 'create';
+                }
+            }
+        }
+        fs.writeFileSync(output, yaml_1.default.stringify(plan, { lineWidth: 0 }), 'utf8');
+        const skipActions = plan.groups
+            .flatMap((g) => g.actions)
+            .filter((a) => a.action === 'skip');
+        const skipCount = skipActions.length;
+        const skipIdSet = new Set(skipActions.map((a) => `${a.type}:${a.name}`));
+        if (skipExisting && skipCount > 0) {
+            verifyResult.summary.skip = skipCount;
+            verifyResult.summary.update =
+                (verifyResult.summary.update ?? 0) - skipCount;
+        }
+        console.log((0, formatVerifyResultsText_1.formatVerifyResultsText)(verifyResult.entries, verifyResult.summary, 'pre-restore', verbosity_1.verbosityState.level, skipIdSet.size > 0 ? skipIdSet : undefined));
+        if (skipCount > 0) {
+            console.log(`  (${skipCount} existing objects will be skipped)`);
+        }
+        console.log(`Plan updated and saved to ${output}`);
+        console.log(`Next step: adt-backup restore --plan ${output} --target ${destination || '<sys>'}`);
+        return;
+    }
+    if (command === 'restore') {
+        if (!client)
+            throw new Error('Client required');
+        const planPath = args.plan;
+        if (!planPath || typeof planPath !== 'string')
+            throw new Error('Missing --plan');
+        const plan = yaml_1.default.parse(fs.readFileSync(planPath, 'utf8'));
+        const backup = yaml_1.default.parse(fs.readFileSync(plan.backupFile, 'utf8'));
+        const allNodes = (0, flattenTree_1.flattenTree)(backup.root);
+        const _nodeMap = new Map(allNodes.map((n) => [(0, getNodeObjectId_1.getNodeObjectId)(n), n]));
+        const _backupPackageNames = new Set(allNodes.filter((n) => n.type === 'package').map((n) => n.name));
+        const noActivate = Boolean(args['no-activate']);
+        const activate = !noActivate && (Boolean(args.activate) || !args['no-activate-on-update']);
+        const activateOnCreate = !noActivate && !args['no-activate-on-create'];
+        const superPackage = typeof args['super-package'] === 'string'
+            ? args['super-package']
+            : undefined;
+        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'
+            ? args['software-component']
+            : undefined, superPackage, transportLayer);
+        console.log('Restore completed. Running post-restore check on TARGET system...');
+        const postResult = await (0, verifyBackup_1.verifyBackup)(client, backup, {
+            mode: 'post-restore',
+        });
+        console.log((0, formatVerifyResultsText_1.formatVerifyResultsText)(postResult.entries, postResult.summary, 'post-restore', verbosity_1.verbosityState.level));
+        return;
+    }
+    if (command === 'activate') {
+        if (!client)
+            throw new Error('Client required');
+        const planPath = args.plan;
+        if (!planPath || typeof planPath !== 'string')
+            throw new Error('Missing --plan');
+        const filter = typeof args.filter === 'string' ? args.filter : 'all';
+        if (!['skip', 'update', 'all'].includes(filter)) {
+            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) {
+            console.log('No objects to activate.');
+            return;
+        }
+        console.log(`Activating ${filtered.length} object(s) (filter: ${filter})...`);
+        // Group 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 });
+            }
+            if (groupRefs.length === 0)
+                continue;
+            (0, logVerbose_1.logVerbose)(2, `  [GROUP ${group.id}] Activating ${groupRefs.length} object(s)...`);
+            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}`);
+                }
+            }
+            catch (error) {
+                const message = error instanceof Error ? error.message : String(error);
+                failed += groupRefs.length;
+                (0, logVerbose_1.logVerbose)(1, `  [!] Group ${group.id} activation failed: ${message}`);
+            }
+        }
+        skipped = allActions.length - activated - failed;
+        console.log(`Activation complete: ${activated} activated, ${skipped} skipped, ${failed} failed`);
+        return;
+    }
     if (command === 'diff') {
+        if (!client)
+            throw new Error('Client required');
         const input = args.input;
         const objectSpec = args.object;
         const diffAll = Boolean(args.all);
-        const showOk = Boolean(args['show-ok']);
+        const _showOk = Boolean(args['show-ok']);
         const objectSpecValue = typeof objectSpec === 'string' ? objectSpec : '';
-        if (typeof input !== 'string') {
+        if (typeof input !== 'string')
             throw new Error('Missing --input');
-        }
-        if (!diffAll && typeof objectSpec !== 'string') {
-            throw new Error('Missing --object (or use --all)');
-        }
+        if (!diffAll && typeof objectSpec !== 'string')
+            throw new Error('Missing --object');
         const raw = fs.readFileSync(input, 'utf8');
         const parsed = yaml_1.default.parse(raw);
-        if (!parsed || typeof parsed !== 'object') {
-            throw new Error('Invalid backup file format');
-        }
         (0, verifyBackupChecksum_1.verifyBackupChecksum)(parsed);
         const diffMetadata = async (label, backupText, metadataXml, showNoDiff) => {
             const beforeMeta = (0, extractMetadata_1.extractMetadata)(backupText);
             const afterMeta = (0, extractMetadata_1.extractMetadata)(metadataXml);
-            const changes = [];
-            if (beforeMeta.packageName !== afterMeta.packageName) {
-                changes.push({
-                    key: 'packageName',
-                    before: beforeMeta.packageName,
-                    after: afterMeta.packageName,
-                });
-            }
-            if (changes.length === 0) {
-                if (showNoDiff) {
-                    console.log(`=== ${label}`);
-                    console.log('No differences');
-                }
+            if (beforeMeta.packageName === afterMeta.packageName) {
+                if (showNoDiff)
+                    console.log(`=== ${label}\nNo differences`);
                 return false;
             }
-            console.log(`=== ${label}`);
-            for (const change of changes) {
-                console.log(`changed ${change.key}: "${change.before ?? ''}" -> "${change.after ?? ''}"`);
-            }
+            console.log(`=== ${label}\nchanged packageName: "${beforeMeta.packageName ?? ''}" -> "${afterMeta.packageName ?? ''}"`);
             return true;
         };
         const diffSource = async (label, backupText, actualSource, showNoDiff) => {
             const unified = (0, diffUnified_1.diffUnified)(backupText, actualSource);
             if (!unified.trim()) {
-                if (showNoDiff) {
-                    console.log(`=== ${label}`);
-                    console.log('No differences');
-                }
+                if (showNoDiff)
+                    console.log(`=== ${label}\nNo differences`);
                 return false;
             }
-            console.log(`=== ${label}`);
-            console.log(unified);
+            console.log(`=== ${label}\n${unified}`);
             return true;
         };
-        let hasAnyDiff = false;
         if (parsed.schemaVersion === 2) {
-            const tree = parsed;
-            (0, verifyTreeChecksums_1.verifyTreeChecksums)(tree.root);
+            (0, verifyTreeChecksums_1.verifyTreeChecksums)(parsed.root);
             if (!diffAll) {
                 const spec = (0, parseObjectSpec_1.parseObjectSpec)(objectSpecValue);
-                const node = (0, findNodeInTree_1.findNodeInTree)(tree.root, spec);
-                if (!node || !node.type) {
-                    throw new Error(`Object not found: ${(0, formatObjectSpec_1.formatObjectSpec)(spec)}`);
-                }
-                if (!node.codeBase64) {
-                    throw new Error('Object has no payload to diff');
-                }
-                const label = (0, formatObjectSpec_1.formatObjectSpec)(spec);
+                const node = (0, findNodeInTree_1.findNodeInTree)(parsed.root, spec);
+                if (!node || !node.codeBase64)
+                    throw new Error('Object not found');
                 const backupText = (0, decodeBase64_1.decodeBase64)(node.codeBase64);
                 if (node.codeFormat === 'xml') {
-                    try {
-                        const metadataXml = await (0, readMetadataXmlForType_1.readMetadataXmlForType)(client, node.type, node.name, node.functionGroupName);
-                        if (!metadataXml) {
-                            throw new Error('Metadata not available for diff');
-                        }
-                        const hasDiff = await diffMetadata(label, backupText, metadataXml, true);
-                        if (!hasDiff) {
-                            console.log('No metadata differences detected');
-                        }
-                        return;
-                    }
-                    catch (_error) {
-                        const otherType = await (0, findOtherType_1.findOtherType)(client, node.type, node.name);
-                        if (otherType && otherType !== node.type) {
-                            console.log(`=== ${label}`);
-                            console.log(`changed type: "${node.type}" -> "${otherType}"`);
-                            return;
-                        }
-                        throw _error;
-                    }
-                }
-                const actualSource = await (0, readSourceText_1.readSourceText)(client, {
-                    type: node.type,
-                    name: node.name,
-                    functionGroupName: node.functionGroupName,
-                });
-                if (actualSource === undefined) {
-                    throw new Error('Source not available for diff');
+                    const metadataXml = await (0, readMetadataXmlForType_1.readMetadataXmlForType)(client, node.type, node.name, node.functionGroupName);
+                    if (metadataXml)
+                        await diffMetadata((0, formatObjectSpec_1.formatObjectSpec)(spec), backupText, metadataXml, true);
                 }
-                const hasDiff = await diffSource(label, backupText, actualSource, true);
-                if (!hasDiff) {
-                    console.log('No source differences detected');
+                else {
+                    const actualSource = await (0, readSourceText_1.readSourceText)(client, spec);
+                    await diffSource((0, formatObjectSpec_1.formatObjectSpec)(spec), backupText, actualSource ?? '', true);
                 }
                 return;
             }
-            const nodes = [];
-            (0, collectBackupNodes_1.collectBackupNodes)(tree.root, nodes);
-            for (const node of nodes) {
-                if (!node.type || !node.codeBase64) {
-                    continue;
-                }
-                const spec = {
-                    type: node.type,
-                    name: node.name,
-                    functionGroupName: node.functionGroupName,
-                };
-                const label = (0, formatObjectSpec_1.formatObjectSpec)(spec);
-                const backupText = (0, decodeBase64_1.decodeBase64)(node.codeBase64);
-                if (node.codeFormat === 'xml') {
-                    try {
-                        const metadataXml = await (0, readMetadataXmlForType_1.readMetadataXmlForType)(client, node.type, node.name, node.functionGroupName);
-                        if (!metadataXml) {
-                            continue;
-                        }
-                        const hasDiff = await diffMetadata(label, backupText, metadataXml, showOk);
-                        if (hasDiff) {
-                            hasAnyDiff = true;
-                        }
-                        continue;
-                    }
-                    catch (_error) {
-                        const otherType = await (0, findOtherType_1.findOtherType)(client, node.type, node.name);
-                        if (otherType && otherType !== node.type) {
-                            console.log(`=== ${label}`);
-                            console.log(`changed type: "${node.type}" -> "${otherType}"`);
-                            hasAnyDiff = true;
-                        }
-                        continue;
-                    }
-                }
-                const actualSource = await (0, readSourceText_1.readSourceText)(client, spec);
-                if (actualSource === undefined) {
-                    continue;
-                }
-                const hasDiff = await diffSource(label, backupText, actualSource, showOk);
-                if (hasDiff) {
-                    hasAnyDiff = true;
-                }
-            }
-            if (!hasAnyDiff) {
-                console.log('No differences detected');
-            }
-            return;
-        }
-        const flat = parsed;
-        if (!Array.isArray(flat.objects)) {
-            throw new Error('Invalid backup file format');
-        }
-        if (!diffAll) {
-            const spec = (0, parseObjectSpec_1.parseObjectSpec)(objectSpecValue);
-            const obj = flat.objects.find((item) => item.type === spec.type &&
-                item.name === spec.name &&
-                (spec.functionGroupName
-                    ? item.functionGroupName === spec.functionGroupName
-                    : true));
-            if (!obj) {
-                throw new Error(`Object not found: ${(0, formatObjectSpec_1.formatObjectSpec)(spec)}`);
-            }
-            if (!obj.source) {
-                throw new Error('Object has no payload to diff');
-            }
-            const actualSource = await (0, readSourceText_1.readSourceText)(client, spec);
-            if (actualSource === undefined) {
-                throw new Error('Source not available for diff');
-            }
-            const hasDiff = await diffSource((0, formatObjectSpec_1.formatObjectSpec)(spec), obj.source, actualSource, true);
-            if (!hasDiff) {
-                console.log('No source differences detected');
-            }
-            return;
-        }
-        for (const obj of flat.objects) {
-            if (!obj.source) {
-                continue;
-            }
-            const spec = {
-                type: obj.type,
-                name: obj.name,
-                functionGroupName: obj.functionGroupName,
-            };
-            const actualSource = await (0, readSourceText_1.readSourceText)(client, spec);
-            if (actualSource === undefined) {
-                continue;
-            }
-            const hasDiff = await diffSource((0, formatObjectSpec_1.formatObjectSpec)(spec), obj.source, actualSource, showOk);
-            if (hasDiff) {
-                hasAnyDiff = true;
-            }
-        }
-        if (!hasAnyDiff) {
-            console.log('No differences detected');
         }
         return;
     }
-    if (command === 'verify') {
+    if (command === 'validate') {
         const input = args.input;
-        if (typeof input !== 'string') {
+        if (typeof input !== 'string')
             throw new Error('Missing --input');
-        }
-        const format = typeof args.format === 'string' ? args.format : 'text';
-        const strict = Boolean(args.strict);
-        const raw = fs.readFileSync(input, 'utf8');
-        const parsed = yaml_1.default.parse(raw);
-        if (!parsed || typeof parsed !== 'object') {
-            throw new Error('Invalid backup file format');
-        }
+        const parsed = yaml_1.default.parse(fs.readFileSync(input, 'utf8'));
         (0, verifyBackupChecksum_1.verifyBackupChecksum)(parsed);
-        if (parsed.schemaVersion === 2) {
+        if (parsed.schemaVersion === 2)
             (0, verifyTreeChecksums_1.verifyTreeChecksums)(parsed.root);
-        }
-        const result = await (0, verifyBackup_1.verifyBackup)(client, parsed, { strict });
-        if (format === 'json') {
-            console.log(JSON.stringify(result, null, 2));
-        }
-        else {
-            console.log((0, formatVerifyResultsText_1.formatVerifyResultsText)(result.entries, result.summary));
-        }
-        if (result.summary.conflicts > 0) {
-            throw new Error(`Conflicts found: ${result.summary.conflicts}`);
-        }
+        console.log('Backup validated');
         return;
     }
-    if (command === 'restore') {
+    if (command === 'extract') {
         const input = args.input;
-        if (typeof input !== 'string') {
+        const objectSpec = args.object;
+        const output = args.out;
+        if (typeof input !== 'string' ||
+            typeof objectSpec !== 'string' ||
+            typeof output !== 'string')
+            throw new Error('Missing args');
+        const parsed = yaml_1.default.parse(fs.readFileSync(input, 'utf8'));
+        const spec = (0, parseObjectSpec_1.parseObjectSpec)(objectSpec);
+        const node = (0, findNodeInTree_1.findNodeInTree)(parsed.root, spec);
+        if (!node || !node.codeBase64)
+            throw new Error('Not found');
+        fs.writeFileSync(output, (0, decodeBase64_1.decodeBase64)(node.codeBase64), 'utf8');
+        console.log(`Extracted to ${output}`);
+        return;
+    }
+    if (command === 'patch') {
+        const input = args.input;
+        const objectSpec = args.object;
+        const filePath = args.file;
+        if (typeof input !== 'string' ||
+            typeof objectSpec !== 'string' ||
+            typeof filePath !== 'string')
+            throw new Error('Missing args');
+        const output = typeof args.output === 'string' ? args.output : input;
+        const parsed = yaml_1.default.parse(fs.readFileSync(input, 'utf8'));
+        const node = (0, findNodeInTree_1.findNodeInTree)(parsed.root, (0, parseObjectSpec_1.parseObjectSpec)(objectSpec));
+        if (!node)
+            throw new Error('Not found');
+        node.codeBase64 = (0, encodeBase64_1.encodeBase64)(fs.readFileSync(filePath, 'utf8'));
+        node.codeChecksum = (0, computeCodeChecksum_1.computeCodeChecksum)(node.codeBase64);
+        (0, updateTreeChecksums_1.updateTreeChecksums)(parsed.root);
+        parsed.checksum = (0, computeBackupChecksum_1.computeBackupChecksum)(parsed);
+        fs.writeFileSync(output, yaml_1.default.stringify(parsed, { lineWidth: 0 }), 'utf8');
+        console.log(`Backup updated`);
+        return;
+    }
+    if (command === 'check') {
+        if (!client)
+            throw new Error('Client required');
+        const input = args.input;
+        if (typeof input !== 'string')
             throw new Error('Missing --input');
-        }
-        (0, logVerbose_1.logVerbose)(2, `Starting restore from ${input}`);
-        const raw = fs.readFileSync(input, 'utf8');
-        const mode = args.mode || 'upsert';
-        const activateOnUpdate = Boolean(args.activate) || !args['no-activate-on-update'];
-        const parsed = yaml_1.default.parse(raw);
-        if (!parsed || typeof parsed !== 'object') {
-            throw new Error('Invalid backup file format');
-        }
-        const force = Boolean(args.force);
-        const strict = Boolean(args.strict);
-        const dangerous = Boolean(args.dangerous);
-        const activateOnCreate = !args['no-activate-on-create'];
-        const transportRequest = typeof args.transport === 'string' ? args.transport : undefined;
-        const softwareComponent = typeof args['software-component'] === 'string'
-            ? args['software-component']
-            : undefined;
-        if (transportRequest) {
-            (0, logVerbose_1.logVerbose)(1, `Using transport request for restore: ${transportRequest}`);
-        }
-        if (softwareComponent) {
-            (0, logVerbose_1.logVerbose)(1, `Using software component override for packages: ${softwareComponent}`);
-        }
-        if (parsed.schemaVersion === 2) {
-            const tree = parsed;
-            (0, verifyBackupChecksum_1.verifyBackupChecksum)(tree);
-            (0, verifyTreeChecksums_1.verifyTreeChecksums)(tree.root);
-            if (dangerous) {
-                (0, logVerbose_1.logVerbose)(1, `Dangerous mode: deleting ${tree.package} objects from backup before restore`);
-                await (0, deleteBackupObjects_1.deleteBackupObjects)(client, tree, transportRequest);
-            }
-            if (!force) {
-                const result = await (0, verifyBackup_1.verifyBackup)(client, tree, { strict });
-                if (result.summary.conflicts > 0) {
-                    throw new Error(`Conflicts found: ${result.summary.conflicts}. Use --force to restore anyway.`);
-                }
-                const plan = (0, buildRestorePlan_1.buildRestorePlan)(tree.root, result.entries);
-                const summary = plan.reduce((acc, item) => {
-                    acc[item.action] = (acc[item.action] || 0) + 1;
-                    return acc;
-                }, {});
-                (0, logVerbose_1.logVerbose)(1, `Restore plan: create ${summary.create || 0}, update ${summary.update || 0}, skip ${summary.skip || 0}, error ${summary.error || 0}`);
-                for (const item of plan) {
-                    if (item.action === 'skip') {
-                        continue;
-                    }
-                    const spec = (0, getNodeObjectSpec_1.getNodeObjectSpec)(item.node);
-                    const label = spec ? (0, formatObjectSpec_1.formatObjectSpec)(spec) : item.node.name;
-                    (0, logVerbose_1.logVerbose)(2, `Plan ${item.action}: ${label} (${item.status})`);
-                }
-                const restoreIds = new Set(plan
-                    .filter((item) => item.action === 'create' || item.action === 'update')
-                    .map((item) => item.id));
-                const restoreActions = new Map();
-                for (const item of plan) {
-                    if (item.action === 'create') {
-                        restoreActions.set(item.id, 'create');
-                    }
-                    else if (item.action === 'update') {
-                        restoreActions.set(item.id, 'update');
-                    }
-                }
-                if (restoreIds.size === 0) {
-                    console.log('Restore skipped: no changes detected');
-                    return;
-                }
-                (0, logVerbose_1.logVerbose)(2, `Restoring tree backup for package ${tree.package}`);
-                await (0, restoreTreeBackup_1.restoreTreeBackup)(client, tree.root, mode, activateOnUpdate, transportRequest, restoreIds, restoreActions, activateOnCreate, softwareComponent);
-                console.log('Restore completed');
-                return;
-            }
-            (0, logVerbose_1.logVerbose)(2, `Restoring tree backup for package ${tree.package}`);
-            await (0, restoreTreeBackup_1.restoreTreeBackup)(client, tree.root, mode, activateOnUpdate, transportRequest, undefined, undefined, activateOnCreate, softwareComponent);
-            console.log('Restore completed');
-            return;
-        }
-        if (!Array.isArray(parsed.objects)) {
-            throw new Error('Invalid backup file format');
-        }
-        const flat = parsed;
-        (0, verifyBackupChecksum_1.verifyBackupChecksum)(flat);
-        if (dangerous) {
-            throw new Error('Dangerous mode is supported only for package backups');
-        }
-        if (!force) {
-            const result = await (0, verifyBackup_1.verifyBackup)(client, flat, { strict });
-            if (result.summary.conflicts > 0) {
-                throw new Error(`Conflicts found: ${result.summary.conflicts}. Use --force to restore anyway.`);
-            }
-            const restoreActions = new Map();
-            for (const entry of result.entries) {
-                if (entry.status === 'missing') {
-                    restoreActions.set(`${entry.type}:${entry.name}`, 'create');
-                }
-                else if (entry.status === 'package-mismatch' ||
-                    entry.status === 'source-mismatch') {
-                    restoreActions.set(`${entry.type}:${entry.name}`, 'update');
-                }
-            }
-            if (restoreActions.size === 0) {
-                console.log('Restore skipped: no changes detected');
-                return;
-            }
-            (0, logVerbose_1.logVerbose)(2, `Restoring flat backup (${flat.objects.length} objects)`);
-            await (0, restoreObjects_1.restoreObjects)(client, flat.objects, mode, activateOnUpdate, transportRequest, restoreActions, activateOnCreate);
-            console.log(`Restore completed for ${flat.objects.length} object(s)`);
-            return;
-        }
-        (0, logVerbose_1.logVerbose)(2, `Restoring flat backup (${flat.objects.length} objects)`);
-        await (0, restoreObjects_1.restoreObjects)(client, flat.objects, mode, activateOnUpdate, transportRequest, undefined, activateOnCreate);
-        console.log(`Restore completed for ${flat.objects.length} object(s)`);
+        const backup = yaml_1.default.parse(fs.readFileSync(input, 'utf8'));
+        const result = await (0, verifyBackup_1.verifyBackup)(client, backup, {
+            strict: Boolean(args.strict),
+        });
+        console.log((0, formatVerifyResultsText_1.formatVerifyResultsText)(result.entries, result.summary, 'pre-restore', verbosity_1.verbosityState.level));
         return;
     }
     throw new Error(`Unknown command: ${command}`);
 }
 function enableLogFile(logFile) {
     const dir = path.dirname(logFile);
-    if (dir && dir !== '.') {
+    if (dir && dir !== '.')
         fs.mkdirSync(dir, { recursive: true });
-    }
     const stream = fs.createWriteStream(logFile, { flags: 'a' });
-    const writeLine = (args) => {
-        const line = args.map(formatLogArg).join(' ');
-        stream.write(`${line}\n`);
-    };
     const wrap = (fn) => (...args) => {
         fn(...args);
-        writeLine(args);
+        stream.write(`${args.map((a) => (typeof a === 'string' ? a : JSON.stringify(a))).join(' ')}\n`);
     };
     console.log = wrap(console.log.bind(console));
-    console.info = wrap(console.info.bind(console));
-    console.warn = wrap(console.warn.bind(console));
     console.error = wrap(console.error.bind(console));
 }
-function formatLogArg(arg) {
-    if (arg instanceof Error) {
-        return (0, redact_1.redactText)(arg.stack ?? arg.message);
-    }
-    if (typeof arg === 'string') {
-        return (0, redact_1.redactText)(arg);
-    }
-    try {
-        return (0, redact_1.safeStringify)(arg);
-    }
-    catch {
-        return String(arg);
-    }
-}