@opscompass/skills 0.1.0

package/skills/opscompass-resources/scripts/list_and_fetch_latest_configs.js

@@ -0,0 +1,714 @@
+import { mkdirSync, writeFileSync } from "node:fs";
+import path from "node:path";
+import { spawn } from "node:child_process";
+import { isMainModule } from "../.opscompass-runtime/tools/cli-entrypoint.js";
+import { resolveCliContext } from "../.opscompass-runtime/tools/opsc-cli-context.js";
+import * as brc from "./build_resources_command.js";
+import * as moc from "./map_oracle_workloads_to_platform_cpus.js";
+import * as slc from "./summarize_latest_configuration.js";
+function recordOf(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value)
+        ? value
+        : {};
+}
+function errorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+function runJsonCommand(command, verbose, logger, execution) {
+    return new Promise((resolve, reject) => {
+        if (execution.signal?.aborted) {
+            reject(new Error("Opscompass command aborted."));
+            return;
+        }
+        if (verbose)
+            logger.error(`$ ${command.join(" ")}`);
+        let stdout = "", stderr = "";
+        const child = spawn(execution.context.cliEntryPoint, command.slice(1), {
+            shell: false,
+            stdio: ["ignore", "pipe", "pipe"],
+            cwd: execution.workspaceRoot,
+            env: execution.env,
+            signal: execution.signal,
+            detached: process.platform !== "win32",
+        });
+        let graceTimer;
+        const kill = () => {
+            try {
+                if (process.platform !== "win32" && child.pid)
+                    process.kill(-child.pid, "SIGTERM");
+                else
+                    child.kill("SIGTERM");
+            }
+            catch {
+                // The process may already have exited.
+            }
+            if (graceTimer === undefined) {
+                graceTimer = setTimeout(() => {
+                    try {
+                        if (process.platform !== "win32" && child.pid)
+                            process.kill(-child.pid, "SIGKILL");
+                        else
+                            child.kill("SIGKILL");
+                    }
+                    catch {
+                        // The process group may already have exited.
+                    }
+                }, 5_000);
+            }
+        };
+        execution.signal?.addEventListener("abort", kill, { once: true });
+        child.stdout.on("data", (chunk) => {
+            stdout += chunk;
+        });
+        child.stderr.on("data", (chunk) => {
+            stderr += chunk;
+        });
+        child.once("error", (error) => {
+            // AbortError is emitted before close; wait until the child has stopped.
+            if (!execution.signal?.aborted)
+                reject(error);
+        });
+        child.once("close", (code) => {
+            clearTimeout(graceTimer);
+            execution.signal?.removeEventListener("abort", kill);
+            if (execution.signal?.aborted)
+                return reject(new Error("Opscompass command aborted."));
+            if (code !== 0)
+                return reject(new Error(`command failed (${code}): ${command.join(" ")}\n${stderr.trim()}`));
+            try {
+                resolve(JSON.parse(stdout));
+            }
+            catch (error) {
+                reject(new Error(`command did not return valid JSON: ${command.join(" ")}\n${errorMessage(error)}\nstdout:\n${stdout.slice(0, 2000)}`));
+            }
+        });
+    });
+}
+function saveJson(filePath, payload, workspaceRoot) {
+    if (!filePath)
+        return;
+    filePath = path.resolve(workspaceRoot, filePath);
+    mkdirSync(path.dirname(filePath), { recursive: true });
+    writeFileSync(filePath, JSON.stringify(payload, null, 2), "utf8");
+}
+function saveText(filePath, text, workspaceRoot) {
+    if (!filePath)
+        return;
+    filePath = path.resolve(workspaceRoot, filePath);
+    mkdirSync(path.dirname(filePath), { recursive: true });
+    writeFileSync(filePath, text, "utf8");
+}
+function parseArgs(argv, logger = console) {
+    const args = {
+        param: [],
+        summaryTop: 5,
+        ignoreDefaults: false,
+        noConfigs: false,
+        stopOnError: false,
+        verbose: false,
+    };
+    const values = new Map([
+        ["--company", "company"],
+        ["--cli", "cli"],
+        ["--param", "param"],
+        ["--max-resources", "maxResources"],
+        ["--page-size-hint", "pageSizeHint"],
+        ["--max-pages", "maxPages"],
+        ["--list-output-json", "listOutputJson"],
+        ["--configs-output-json", "configsOutputJson"],
+        ["--compliance-status", "complianceStatus"],
+        ["--compliance-output-json", "complianceOutputJson"],
+        ["--summary-output", "summaryOutput"],
+        ["--summary-top", "summaryTop"],
+    ]);
+    for (let i = 0; i < argv.length; i += 1) {
+        const flag = argv[i];
+        if (flag === "--no-configs")
+            args.noConfigs = true;
+        else if (flag === "--stop-on-error")
+            args.stopOnError = true;
+        else if (flag === "--verbose")
+            args.verbose = true;
+        else if (flag === "--ignore-defaults")
+            args.ignoreDefaults = true;
+        else if (values.has(flag)) {
+            if (++i >= argv.length)
+                throw new Error(`argument ${flag}: expected one argument`);
+            const key = values.get(flag);
+            if (key === "param")
+                args.param.push(argv[i]);
+            else if (key === "maxResources" ||
+                key === "pageSizeHint" ||
+                key === "maxPages" ||
+                key === "summaryTop") {
+                const value = Number(argv[i]);
+                if (!Number.isInteger(value))
+                    throw new Error(`argument ${flag}: invalid int value: '${argv[i]}'`);
+                args[key] = value;
+            }
+            else if (key === "company" ||
+                key === "cli" ||
+                key === "listOutputJson" ||
+                key === "configsOutputJson" ||
+                key === "complianceStatus" ||
+                key === "complianceOutputJson" ||
+                key === "summaryOutput")
+                args[key] = argv[i];
+        }
+        else if (flag === "--help" || flag === "-h") {
+            logger.log("List resources, fetch latest configs by id, and summarize the results.");
+            args.help = true;
+            return args;
+        }
+        else
+            throw new Error(`unrecognized arguments: ${flag}`);
+    }
+    return args;
+}
+function builderList(company, params, context) {
+    const args = {
+        action: "list",
+        company,
+        param: params,
+        execute: false,
+        ignoreDefaults: false,
+    };
+    const map = brc.parseParamMap(params);
+    brc.validateArgs(args, map);
+    return brc.buildCommand(args, map, context);
+}
+function builderGet(company, id, context) {
+    const args = {
+        action: "get-latest-configuration",
+        company,
+        resourceNumericId: id,
+        param: [],
+        execute: false,
+        ignoreDefaults: false,
+    };
+    brc.validateArgs(args, new Map());
+    return brc.buildCommand(args, new Map(), context);
+}
+function builderCompliance(company, id, status, context) {
+    const args = {
+        action: "get-compliance",
+        company,
+        resourceNumericId: id,
+        param: [`status=${status}`],
+        execute: false,
+        ignoreDefaults: false,
+    };
+    const map = brc.parseParamMap(args.param);
+    brc.validateArgs(args, map);
+    return brc.buildCommand(args, map, context);
+}
+function addOrReplaceParam(params, key, value) {
+    return [
+        ...params.filter((item) => !item.startsWith(`${key}=`)),
+        `${key}=${value}`,
+    ];
+}
+function docOf(cfg) {
+    return recordOf(cfg.document);
+}
+function cfgName(cfg) {
+    return String(cfg.name || cfg._list_name || "(unnamed)");
+}
+export function summarizeComplianceBatches(batches, topN, status) {
+    const oracleOnly = batches.length > 0 &&
+        batches.every((batch) => String(batch.resource_type || "") === "databases/oracle");
+    let findingsTotal = 0;
+    const severity = new Map(), checks = new Map(), resources = [];
+    for (const batch of batches) {
+        if (!Array.isArray(batch.findings))
+            continue;
+        let count = 0;
+        for (const item of batch.findings) {
+            if (!item || typeof item !== "object" || Array.isArray(item))
+                continue;
+            findingsTotal += 1;
+            count += 1;
+            const sev = String(item.checkSeverity || "unknown"), check = String(item.checkName || "(unnamed check)");
+            severity.set(sev, (severity.get(sev) || 0) + 1);
+            checks.set(check, (checks.get(check) || 0) + 1);
+        }
+        if (count)
+            resources.push([String(batch.resource_name || batch.resource_id), count]);
+    }
+    const lines = [
+        oracleOnly
+            ? `Oracle license compliance summary (status=${status})`
+            : `Compliance summary (status=${status})`,
+        `Resources checked: ${batches.length}`,
+        `Total findings: ${findingsTotal}`,
+    ];
+    if (oracleOnly) {
+        const versions = new Map(), editions = new Map();
+        for (const batch of batches) {
+            const version = String(batch.oracle_version || "").trim(), edition = String(batch.oracle_edition || "").trim();
+            if (version)
+                versions.set(version, (versions.get(version) || 0) + 1);
+            if (edition)
+                editions.set(edition, (editions.get(edition) || 0) + 1);
+        }
+        lines.push("", "Oracle configuration context:");
+        const format = (map) => [...map]
+            .sort((a, b) => b[1] - a[1] || a[0].localeCompare(b[0]))
+            .slice(0, topN)
+            .map(([name, count]) => `${name}: ${count}`)
+            .join(", ") || "none";
+        lines.push(`- versions: ${format(versions)}`, `- editions: ${format(editions)}`);
+    }
+    const formatCounts = (map) => [...map].sort((a, b) => b[1] - a[1] || a[0].localeCompare(b[0]));
+    lines.push("", "Findings by severity:");
+    for (const [name, count] of formatCounts(severity))
+        lines.push(`- ${name}: ${count}`);
+    if (!severity.size)
+        lines.push("- none");
+    lines.push("", `Top ${topN} checks by frequency:`);
+    for (const [name, count] of formatCounts(checks).slice(0, topN))
+        lines.push(`- ${name}: ${count}`);
+    if (!checks.size)
+        lines.push("- none");
+    lines.push("", `Top ${topN} resources by finding count:`);
+    for (const [name, count] of resources
+        .sort((a, b) => b[1] - a[1] || a[0].localeCompare(b[0]))
+        .slice(0, topN))
+        lines.push(`- ${name}: ${count}`);
+    if (!resources.length)
+        lines.push("- none");
+    lines.push("", "Sample findings:");
+    let shown = 0;
+    for (const batch of batches) {
+        if (!Array.isArray(batch.findings))
+            continue;
+        for (const item of batch.findings) {
+            if (!item || typeof item !== "object" || Array.isArray(item))
+                continue;
+            const name = String(batch.resource_name || batch.resource_id), check = String(item.checkName || "(unnamed check)"), sev = String(item.checkSeverity || "unknown"), message = String(item.errorMessage || "");
+            let suffix = "";
+            if (oracleOnly) {
+                const context = [];
+                if (String(batch.oracle_version || "").trim())
+                    context.push(`version=${String(batch.oracle_version).trim()}`);
+                if (String(batch.oracle_edition || "").trim())
+                    context.push(`edition=${String(batch.oracle_edition).trim()}`);
+                if (context.length)
+                    suffix = ` (${context.join(", ")})`;
+            }
+            lines.push(`- ${name}${suffix} [${sev}] ${check}`);
+            if (message)
+                lines.push(`  error: ${message}`);
+            if (item.recommendedAction)
+                lines.push(`  fix: ${item.recommendedAction}`);
+            shown += 1;
+            if (shown >= topN)
+                return lines.join("\n");
+        }
+    }
+    if (!shown)
+        lines.push("- none");
+    return lines.join("\n");
+}
+function summarizeVmware(configs, topN) {
+    const vm = configs.filter((cfg) => String(cfg.type || cfg._list_type || "") === "vcenter/virtualMachine"), hosts = configs.filter((cfg) => String(cfg.type || cfg._list_type || "") === "vcenter/host");
+    if (!vm.length && !hosts.length)
+        return "";
+    const hostById = new Map(), hostVmIds = new Map(), matches = [], unmatched = [];
+    for (const host of hosts) {
+        const doc = docOf(host), id = String(doc.id || "").trim();
+        if (id)
+            hostById.set(id, host);
+        const ids = Array.isArray(doc.virtualMachines)
+            ? doc.virtualMachines
+                .filter((item) => item && typeof item === "object")
+                .map((item) => String(recordOf(item).id || "").trim())
+                .filter(Boolean)
+            : [];
+        if (id && ids.length)
+            hostVmIds.set(id, ids);
+    }
+    for (const cfg of vm) {
+        const doc = docOf(cfg), hostRef = doc.host;
+        if (!hostRef || typeof hostRef !== "object" || Array.isArray(hostRef))
+            continue;
+        const id = String(doc.id || "").trim(), name = String(doc.name || cfgName(cfg)).trim(), hostId = String(recordOf(hostRef).id || "").trim(), host = hostById.get(hostId), hostDoc = host ? docOf(host) : {};
+        const cluster = String(recordOf(doc.cluster).name || "").trim(), datacenter = String(recordOf(doc.datacenter).name || "").trim(), matched = Boolean(host && id && (hostVmIds.get(hostId) || []).includes(id));
+        const entry = {
+            name,
+            id,
+            guest: String(doc.guestHostname || "").trim(),
+            hostId,
+            hostName: String(hostDoc.name || recordOf(hostRef).name || "").trim(),
+            cluster: String(recordOf(hostDoc.cluster).name || cluster).trim(),
+            datacenter: String(recordOf(hostDoc.datacenter).name || datacenter).trim(),
+            matched,
+        };
+        (host ? matches : unmatched).push(entry);
+    }
+    const lines = [
+        "VMware relationship summary",
+        `VM configurations collected: ${vm.length}`,
+        `Host configurations collected: ${hosts.length}`,
+        `VMs with host reference: ${matches.length + unmatched.length}`,
+        `VM-to-host matches confirmed from both payloads: ${matches.filter((item) => item.matched).length}`,
+        "",
+        `Top ${topN} VM-to-host relationships:`,
+    ];
+    if (matches.length)
+        for (const item of matches.slice(0, topN)) {
+            const context = [];
+            if (item.guest)
+                context.push(`guest=${item.guest}`);
+            if (item.cluster)
+                context.push(`cluster=${item.cluster}`);
+            if (item.datacenter)
+                context.push(`datacenter=${item.datacenter}`);
+            if (!item.matched)
+                context.push("host-side confirmation=missing");
+            lines.push(`- ${item.name || item.id || "(unnamed vm)"} -> ${item.hostName || item.hostId || "(unknown host)"}${context.length ? ` (${context.join(", ")})` : ""}`);
+        }
+    else
+        lines.push("- none");
+    if (unmatched.length) {
+        lines.push("", `Top ${topN} VM host references without matching host config:`);
+        for (const item of unmatched.slice(0, topN))
+            lines.push(`- ${item.name || item.id || "(unnamed vm)"} -> ${item.hostName || item.hostId || "(unknown host)"}`);
+    }
+    const hostSide = [];
+    for (const [id, ids] of hostVmIds)
+        if (!matches.some((item) => item.hostId === id))
+            hostSide.push(`${String(docOf(hostById.get(id) || {}).name || id).trim()}: ${ids.length} hosted VMs`);
+    if (hostSide.length) {
+        lines.push("", `Top ${topN} hosts with only host-side VM evidence:`);
+        for (const item of hostSide.slice(0, topN))
+            lines.push(`- ${item}`);
+    }
+    return lines.join("\n");
+}
+function summarizeNutanix(configs, topN) {
+    const vm = configs.filter((cfg) => String(cfg.type || cfg._list_type || "") === "Nutanix/Vm"), hosts = configs.filter((cfg) => String(cfg.type || cfg._list_type || "") === "Nutanix/Host"), clusters = configs.filter((cfg) => String(cfg.type || cfg._list_type || "") === "Nutanix/Cluster");
+    if (!vm.length && !hosts.length && !clusters.length)
+        return "";
+    const hostById = new Map(), clusterById = new Map(), nodes = new Map();
+    for (const cfg of hosts) {
+        const d = docOf(cfg);
+        if (d.extId)
+            hostById.set(String(d.extId).trim(), cfg);
+    }
+    for (const cfg of clusters) {
+        const d = docOf(cfg), id = String(d.extId || "").trim();
+        if (id)
+            clusterById.set(id, cfg);
+        const list = recordOf(d.nodes).nodeList;
+        if (id && Array.isArray(list))
+            nodes.set(id, new Set(list
+                .filter((item) => item && typeof item === "object")
+                .map((item) => String(recordOf(item).nodeUuid || "").trim())
+                .filter(Boolean)));
+    }
+    const rows = [];
+    for (const cfg of vm) {
+        const d = docOf(cfg), hostId = String(recordOf(d.host).extId || "").trim(), clusterId = String(recordOf(d.cluster).extId || "").trim(), host = hostById.get(hostId), cluster = clusterById.get(clusterId), hd = docOf(host || {}), cd = docOf(cluster || {}), nics = Array.isArray(d.nics) ? d.nics : [], ips = [], subnets = [];
+        for (const nic of nics) {
+            const info = recordOf(nic).networkInfo;
+            if (!info || typeof info !== "object" || Array.isArray(info))
+                continue;
+            const subnet = recordOf(recordOf(info).subnet);
+            if (subnet.extId)
+                subnets.push(String(subnet.extId).trim());
+            const addresses = recordOf(recordOf(info).ipv4Info).learnedIpAddresses;
+            for (const ip of Array.isArray(addresses) ? addresses : [])
+                if (recordOf(ip).value)
+                    ips.push(String(recordOf(ip).value).trim());
+        }
+        const hostCluster = recordOf(hd.cluster);
+        rows.push({
+            name: String(d.name || cfgName(cfg)).trim(),
+            id: String(d.extId || "").trim(),
+            description: String(d.description || "").trim(),
+            power: String(d.powerState || "").trim(),
+            hostId,
+            hostName: String(hd.hostName || "").trim(),
+            clusterId,
+            clusterName: String(cd.name || hostCluster?.name || "").trim(),
+            ips: ips.slice(0, 3).join(", "),
+            subnets: subnets.slice(0, 3).join(", "),
+            hostMatch: Boolean(host),
+            clusterMatch: Boolean(cluster),
+            nodeMatch: Boolean(nodes.get(clusterId)?.has(hostId)),
+        });
+    }
+    const lines = [
+        "Nutanix relationship summary",
+        `VM configurations collected: ${vm.length}`,
+        `Host configurations collected: ${hosts.length}`,
+        `Cluster configurations collected: ${clusters.length}`,
+        `VMs with host reference: ${rows.filter((item) => item.hostId).length}`,
+        `VMs with cluster reference: ${rows.filter((item) => item.clusterId).length}`,
+        `VM-to-host matches confirmed from host configs: ${rows.filter((item) => item.hostMatch).length}`,
+        `VM-to-cluster matches confirmed from cluster configs: ${rows.filter((item) => item.clusterMatch).length}`,
+        "",
+        `Top ${topN} VM relationships:`,
+    ];
+    if (rows.length)
+        for (const item of rows.slice(0, topN)) {
+            const context = [];
+            if (item.ips)
+                context.push(`ips=${item.ips}`);
+            if (item.power)
+                context.push(`power=${item.power}`);
+            if (item.subnets)
+                context.push(`subnets=${item.subnets}`);
+            if (item.description)
+                context.push(`description=${item.description}`);
+            if (!item.hostMatch)
+                context.push("host-config=missing");
+            if (!item.clusterMatch)
+                context.push("cluster-config=missing");
+            else if (!item.nodeMatch)
+                context.push("cluster-node-confirmation=missing");
+            lines.push(`- ${item.name || item.id || "(unnamed vm)"} -> host=${item.hostName || item.hostId || "(unknown host)"}, cluster=${item.clusterName || item.clusterId || "(unknown cluster)"}${context.length ? ` (${context.join(", ")})` : ""}`);
+        }
+    else
+        lines.push("- none");
+    const migrations = rows.filter((item) => /migrat|move/i.test(item.description));
+    if (migrations.length) {
+        lines.push("", `Top ${topN} migration-related VM descriptions:`);
+        for (const item of migrations.slice(0, topN))
+            lines.push(`- ${item.name || item.id || "(unnamed vm)"}: ${item.description}`);
+    }
+    return lines.join("\n");
+}
+export async function main(argv = process.argv.slice(2), logger = console, execution) {
+    return runWorkflow(argv, logger, execution, execution?.signal);
+}
+async function runWorkflow(argv, logger, execution, signal) {
+    let args;
+    let company;
+    let selected;
+    try {
+        args = parseArgs(argv, logger);
+        if (execution &&
+            args.cli !== undefined &&
+            args.cli !== execution.context.cliCommand)
+            throw new Error("--cli cannot override the host-selected Opscompass CLI.");
+        const context = execution
+            ? { ...execution.context }
+            : resolveCliContext(args.cli);
+        selected = {
+            context,
+            workspaceRoot: execution
+                ? path.resolve(execution.workspaceRoot)
+                : process.cwd(),
+            signal,
+            env: {
+                ...process.env,
+                OPSCOMPASS_CLI_ENTRYPOINT: context.cliEntryPoint,
+                ...(execution
+                    ? { ELECTRON_RUN_AS_NODE: "1", OPSCOMPASS_STUDIO: "1" }
+                    : {}),
+            },
+        };
+        if (args.help)
+            return 0;
+        company = brc.resolveCompany(args.company, {
+            ignoreDefaults: args.ignoreDefaults,
+            context: selected.context,
+        });
+    }
+    catch (error) {
+        logger.error(`Error: ${errorMessage(error)}`);
+        return 2;
+    }
+    if (args.maxResources !== undefined && args.maxResources <= 0)
+        return (logger.error("Error: --max-resources must be greater than 0."), 2);
+    if (args.pageSizeHint !== undefined && args.pageSizeHint <= 0)
+        return (logger.error("Error: --page-size-hint must be greater than 0."), 2);
+    if (args.maxPages !== undefined && args.maxPages <= 0)
+        return (logger.error("Error: --max-pages must be greater than 0."), 2);
+    if (args.maxPages !== undefined && args.pageSizeHint === undefined)
+        return (logger.error("Error: --max-pages requires --page-size-hint."), 2);
+    if (args.pageSizeHint !== undefined &&
+        args.param.some((item) => item.startsWith("skip=")))
+        return (logger.error("Error: do not pass --param skip=... together with --page-size-hint/--max-pages."),
+            2);
+    if (args.summaryTop <= 0)
+        return (logger.error("Error: --summary-top must be greater than 0."), 2);
+    if (args.noConfigs && !args.complianceStatus)
+        return (logger.error("Error: nothing to do. Remove --no-configs or provide --compliance-status."),
+            2);
+    if (args.complianceStatus)
+        try {
+            builderCompliance(company, "1", args.complianceStatus, selected.context);
+        }
+        catch (error) {
+            logger.error(`Error: ${errorMessage(error)}`);
+            return 2;
+        }
+    let base;
+    try {
+        base = builderList(company, args.param, selected.context);
+    }
+    catch (error) {
+        logger.error(`Error: ${errorMessage(error)}`);
+        return 2;
+    }
+    let listPayload = [], listCommands = [], pages = 0;
+    try {
+        if (args.pageSizeHint !== undefined) {
+            const max = args.maxPages || 1;
+            for (let i = 0; i < max; i += 1) {
+                const command = builderList(company, addOrReplaceParam(args.param, "skip", String(i * args.pageSizeHint)), selected.context);
+                const payload = await runJsonCommand(command, args.verbose, logger, selected);
+                if (!Array.isArray(payload)) {
+                    logger.error("Error: resources list did not return a JSON array.");
+                    return 1;
+                }
+                listCommands.push(command);
+                pages += 1;
+                listPayload.push(...payload);
+                if (payload.length < args.pageSizeHint)
+                    break;
+            }
+        }
+        else {
+            const payload = await runJsonCommand(base, args.verbose, logger, selected);
+            if (!Array.isArray(payload)) {
+                logger.error("Error: resources list did not return a JSON array.");
+                return 1;
+            }
+            listPayload = payload;
+            listCommands.push(base);
+            pages = 1;
+        }
+    }
+    catch (error) {
+        logger.error(`Error: ${errorMessage(error)}`);
+        return 1;
+    }
+    saveJson(args.listOutputJson, listPayload, selected.workspaceRoot);
+    const rows = listPayload.filter((item) => item && typeof item === "object" && !Array.isArray(item)), ids = rows
+        .filter((row) => row.id !== undefined && row.id !== null)
+        .map((row) => String(row.id))
+        .slice(0, args.maxResources);
+    if (!ids.length) {
+        logger.log("No resource ids found in list output.");
+        return 0;
+    }
+    const collected = [], configById = new Map(), batches = [], failures = [], rowById = new Map(rows.map((row) => [String(row.id), row]));
+    for (const id of ids) {
+        const source = rowById.get(id) || {}, needsOracle = Boolean(args.complianceStatus &&
+            String(source.type || "") === "databases/oracle"), shouldConfig = !args.noConfigs || needsOracle;
+        if (shouldConfig)
+            try {
+                const payload = await runJsonCommand(builderGet(company, id, selected.context), args.verbose, logger, selected);
+                if (payload && typeof payload === "object" && !Array.isArray(payload)) {
+                    const config = payload;
+                    config._opscompass_resource_numeric_id ??= id;
+                    if (source.name !== undefined)
+                        config._list_name ??= source.name;
+                    if (source.type !== undefined)
+                        config._list_type ??= source.type;
+                    configById.set(id, config);
+                    if (!args.noConfigs)
+                        collected.push(config);
+                }
+                else
+                    throw new Error(`get-latest-configuration returned non-object JSON for id ${id}`);
+            }
+            catch (error) {
+                failures.push({ id, error: `config: ${errorMessage(error)}` });
+                if (args.stopOnError || selected.signal?.aborted) {
+                    logger.error(`Error: ${errorMessage(error)}`);
+                    return 1;
+                }
+            }
+        if (args.complianceStatus)
+            try {
+                const payload = await runJsonCommand(builderCompliance(company, id, args.complianceStatus, selected.context), args.verbose, logger, selected);
+                if (!Array.isArray(payload))
+                    throw new Error(`get-compliance returned non-array JSON for id ${id}`);
+                const doc = docOf(configById.get(id) || {});
+                batches.push({
+                    resource_id: id,
+                    resource_name: source.name,
+                    resource_type: source.type,
+                    status: args.complianceStatus,
+                    oracle_version: doc.version ?? null,
+                    oracle_edition: doc.edition ?? null,
+                    findings: payload,
+                });
+            }
+            catch (error) {
+                failures.push({ id, error: `compliance: ${errorMessage(error)}` });
+                if (args.stopOnError || selected.signal?.aborted) {
+                    logger.error(`Error: ${errorMessage(error)}`);
+                    return 1;
+                }
+            }
+    }
+    saveJson(args.configsOutputJson, collected, selected.workspaceRoot);
+    saveJson(args.complianceOutputJson, batches, selected.workspaceRoot);
+    const sections = [];
+    if (!args.noConfigs) {
+        sections.push(collected.length
+            ? slc.summarizeMany(collected, args.summaryTop)
+            : "No configuration objects collected.");
+        const vmware = summarizeVmware(collected, args.summaryTop), nutanix = summarizeNutanix(collected, args.summaryTop), cpu = moc.summarize(collected, args.summaryTop);
+        if (vmware)
+            sections.push(vmware);
+        if (nutanix)
+            sections.push(nutanix);
+        if (cpu)
+            sections.push(cpu);
+    }
+    if (args.complianceStatus)
+        sections.push(summarizeComplianceBatches(batches, args.summaryTop, args.complianceStatus));
+    let summary = sections.filter(Boolean).join("\n\n");
+    if (failures.length)
+        summary += `\n\nFailures: ${failures.length}\n${failures
+            .slice(0, args.summaryTop)
+            .map((item) => `- id=${item.id}: ${item.error}`)
+            .join("\n")}`;
+    saveText(args.summaryOutput, summary, selected.workspaceRoot);
+    if (listCommands.length === 1)
+        logger.log(`List command: ${listCommands[0].join(" ")}`);
+    else {
+        logger.log("List commands:");
+        for (const command of listCommands)
+            logger.log(`- ${command.join(" ")}`);
+    }
+    logger.log(`List pages fetched: ${pages}`);
+    logger.log(`Resources listed: ${rows.length}`);
+    logger.log(`Resource ids selected for follow-up fetches: ${ids.length}`);
+    if (!args.noConfigs)
+        logger.log(`Configurations collected: ${collected.length}`);
+    if (args.complianceStatus)
+        logger.log(`Compliance batches collected (status=${args.complianceStatus}): ${batches.length}`);
+    if (failures.length)
+        logger.log(`Follow-up fetch failures: ${failures.length}`);
+    logger.log("");
+    logger.log(summary);
+    return failures.length ? 1 : 0;
+}
+if (isMainModule(import.meta.url)) {
+    const controller = new AbortController();
+    let interrupted;
+    const interrupt = (signal) => {
+        interrupted ??= signal;
+        controller.abort();
+    };
+    process.on("SIGINT", interrupt);
+    process.on("SIGTERM", interrupt);
+    try {
+        process.exitCode = await runWorkflow(process.argv.slice(2), console, undefined, controller.signal);
+    }
+    finally {
+        process.removeListener("SIGINT", interrupt);
+        process.removeListener("SIGTERM", interrupt);
+        // Re-raise only after the active command has closed and listeners are gone.
+        if (interrupted)
+            process.kill(process.pid, interrupted);
+    }
+}