@mcp-abap-adt/adt-backup 0.1.0

package/dist/lib/run.js

@@ -0,0 +1,748 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.run = run;
+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 yaml_1 = __importDefault(require("yaml"));
+const getSapConfigFromBroker_1 = require("./auth/getSapConfigFromBroker");
+const backupObject_1 = require("./backup/backupObject");
+const readMetadataXmlForType_1 = require("./backup/readMetadataXmlForType");
+const readSourceText_1 = require("./backup/readSourceText");
+const applyLogEnv_1 = require("./cli/applyLogEnv");
+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");
+const computeBackupChecksum_1 = require("./crypto/computeBackupChecksum");
+const computeCodeChecksum_1 = require("./crypto/computeCodeChecksum");
+const decodeBase64_1 = require("./crypto/decodeBase64");
+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 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 findNodeInTree_1 = require("./tree/findNodeInTree");
+const formatTreeListText_1 = require("./tree/formatTreeListText");
+const getNodeObjectSpec_1 = require("./tree/getNodeObjectSpec");
+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 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);
+    }
+    (0, applyLogEnv_1.applyLogEnv)(verbosity_1.verbosityState.level);
+    const debugAdt = Boolean(args['debug-adt']);
+    if (debugAdt) {
+        process.env.DEBUG_ADT_LIBS = 'true';
+        process.env.DEBUG_CONNECTORS = 'true';
+    }
+    const isHelp = args.help ||
+        argv.includes('-h') ||
+        argv.includes('--help') ||
+        command === 'help';
+    if (!command || (isHelp && !argv[1]) || (command === 'help' && !argv[1])) {
+        console.log((0, usage_1.usage)());
+        process.exit(0);
+    }
+    if (isHelp) {
+        const helpCommand = command === 'help' ? argv[1] : command;
+        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;
+    }
+    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');
+    }
+    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;
+    }
+    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;
+        }
+        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)');
+    }
+    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;
+        const packageName = typeof args.package === 'string' ? args.package : undefined;
+        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');
+            console.log(`Backup written to ${output}`);
+            return;
+        }
+        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())
+            .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);
+        }
+        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');
+        console.log(`Backup written to ${output}`);
+        return;
+    }
+    if (command === 'diff') {
+        const input = args.input;
+        const objectSpec = args.object;
+        const diffAll = Boolean(args.all);
+        const showOk = Boolean(args['show-ok']);
+        const objectSpecValue = typeof objectSpec === 'string' ? objectSpec : '';
+        if (typeof input !== 'string') {
+            throw new Error('Missing --input');
+        }
+        if (!diffAll && typeof objectSpec !== 'string') {
+            throw new Error('Missing --object (or use --all)');
+        }
+        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');
+                }
+                return false;
+            }
+            console.log(`=== ${label}`);
+            for (const change of changes) {
+                console.log(`changed ${change.key}: "${change.before ?? ''}" -> "${change.after ?? ''}"`);
+            }
+            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');
+                }
+                return false;
+            }
+            console.log(`=== ${label}`);
+            console.log(unified);
+            return true;
+        };
+        let hasAnyDiff = false;
+        if (parsed.schemaVersion === 2) {
+            const tree = parsed;
+            (0, verifyTreeChecksums_1.verifyTreeChecksums)(tree.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 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 hasDiff = await diffSource(label, backupText, actualSource, true);
+                if (!hasDiff) {
+                    console.log('No source differences detected');
+                }
+                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') {
+        const input = args.input;
+        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');
+        }
+        (0, verifyBackupChecksum_1.verifyBackupChecksum)(parsed);
+        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}`);
+        }
+        return;
+    }
+    if (command === 'restore') {
+        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)`);
+        return;
+    }
+    throw new Error(`Unknown command: ${command}`);
+}
+function enableLogFile(logFile) {
+    const dir = path.dirname(logFile);
+    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);
+    };
+    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);
+    }
+}