@deniscuciuc/compose-analyzer 1.0.0

package/dist/src/analyzers/security-analyzer.js

@@ -0,0 +1,82 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SecurityAnalyzer = void 0;
+const compose_collector_1 = require("../collectors/compose-collector");
+const constants_1 = require("../constants");
+class SecurityAnalyzer {
+    analyze(services) {
+        const secretsInEnv = [];
+        const privilegedServices = [];
+        const exposedDatabases = [];
+        const issues = [];
+        for (const { name, service } of services) {
+            const envVars = compose_collector_1.ComposeCollector.normalizeEnvironment(service);
+            for (const [key, value] of Object.entries(envVars)) {
+                const matchedPattern = constants_1.SECRET_PATTERNS.find((pattern) => pattern.test(key));
+                if (!matchedPattern ||
+                    !value.trim() ||
+                    this.isInterpolatedValue(value)) {
+                    continue;
+                }
+                secretsInEnv.push({
+                    service: name,
+                    variable: key,
+                    pattern: matchedPattern.source,
+                });
+                issues.push({
+                    service: name,
+                    severity: "high",
+                    category: "security",
+                    title: "Secret value in environment variable",
+                    detail: `Environment variable "${key}" appears to store a plain-text secret.`,
+                    fix: "Prefer Docker secrets or external secret injection instead of embedding values in Compose.",
+                });
+            }
+            if (service.privileged) {
+                privilegedServices.push({ service: name });
+                issues.push({
+                    service: name,
+                    severity: "critical",
+                    category: "security",
+                    title: "Container runs in privileged mode",
+                    detail: `Service "${name}" sets privileged: true, which grants broad host access.`,
+                    fix: "Remove privileged mode and grant only the minimum required capabilities.",
+                });
+            }
+            if (!service.image) {
+                continue;
+            }
+            const baseImage = compose_collector_1.ComposeCollector.baseImageName(service.image);
+            if (!constants_1.SENSITIVE_IMAGES.has(baseImage)) {
+                continue;
+            }
+            for (const port of compose_collector_1.ComposeCollector.normalizePorts(service)) {
+                if (!port.published) {
+                    continue;
+                }
+                if (port.exposesToAllInterfaces) {
+                    const bindAddr = port.hostIp ?? "0.0.0.0";
+                    exposedDatabases.push({
+                        service: name,
+                        image: service.image,
+                        port: port.raw,
+                        bindAddr,
+                    });
+                    issues.push({
+                        service: name,
+                        severity: "high",
+                        category: "security",
+                        title: `Sensitive service port exposed on ${bindAddr}`,
+                        detail: `${service.image} publishes ${port.raw}, making a database or broker reachable from all interfaces.`,
+                        fix: `Bind the port to localhost, for example: 127.0.0.1:${port.published}:${port.target}`,
+                    });
+                }
+            }
+        }
+        return { secretsInEnv, privilegedServices, exposedDatabases, issues };
+    }
+    isInterpolatedValue(value) {
+        return /^\$\{[^}]+\}$/.test(value) || /^\$[A-Z0-9_]+$/i.test(value);
+    }
+}
+exports.SecurityAnalyzer = SecurityAnalyzer;

package/dist/src/cli/options.d.ts

@@ -0,0 +1,16 @@
+import { type Command } from "../constants";
+import type { AnalyzerOptions } from "../types";
+export interface ParsedOptions extends AnalyzerOptions {
+    composeFile: string;
+    compare?: string;
+    command: Command;
+    config?: string;
+    interactive: boolean;
+    json: boolean;
+    outputDir?: string;
+    quiet: boolean;
+    version: boolean;
+}
+export declare function parseOptions(argv?: string[]): ParsedOptions;
+export declare function toAnalyzerOptions(options: ParsedOptions): AnalyzerOptions;
+//# sourceMappingURL=options.d.ts.map

package/dist/src/cli/options.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"options.d.ts","sourceRoot":"","sources":["../../../src/cli/options.ts"],"names":[],"mappings":"AAAA,OAAO,EAAY,KAAK,OAAO,EAAY,MAAM,cAAc,CAAC;AAChE,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,UAAU,CAAC;AAEhD,MAAM,WAAW,aAAc,SAAQ,eAAe;IACrD,WAAW,EAAE,MAAM,CAAC;IACpB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,OAAO,EAAE,OAAO,CAAC;IACjB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,WAAW,EAAE,OAAO,CAAC;IACrB,IAAI,EAAE,OAAO,CAAC;IACd,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,KAAK,EAAE,OAAO,CAAC;IACf,OAAO,EAAE,OAAO,CAAC;CACjB;AAED,wBAAgB,YAAY,CAAC,IAAI,WAAwB,GAAG,aAAa,CA0ExE;AAED,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,aAAa,GAAG,eAAe,CAOzE"}

package/dist/src/cli/options.js

@@ -0,0 +1,129 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseOptions = parseOptions;
+exports.toAnalyzerOptions = toAnalyzerOptions;
+const constants_1 = require("../constants");
+function parseOptions(argv = process.argv.slice(2)) {
+    const options = {
+        composeFile: constants_1.DEFAULTS.composeFile,
+        command: "full",
+        interactive: false,
+        json: false,
+        quiet: false,
+        version: false,
+        withDocker: false,
+        html: false,
+    };
+    for (let index = 0; index < argv.length; index++) {
+        const token = argv[index];
+        switch (token) {
+            case "--file":
+            case "-f":
+                options.composeFile = requireValue(argv, ++index, token);
+                break;
+            case "--with-docker":
+                options.withDocker = true;
+                break;
+            case "--compare":
+                options.compare = requireValue(argv, ++index, token);
+                break;
+            case "--html":
+                options.html = true;
+                break;
+            case "--command":
+            case "-c": {
+                const command = requireValue(argv, ++index, token);
+                if (!constants_1.COMMANDS.includes(command)) {
+                    throw new Error(`Unknown command: ${command}`);
+                }
+                options.command = command;
+                break;
+            }
+            case "--json":
+            case "-j":
+                options.json = true;
+                break;
+            case "--output":
+            case "-o":
+                options.outputDir = requireValue(argv, ++index, token);
+                break;
+            case "--interactive":
+            case "-i":
+            case "start":
+                options.interactive = true;
+                break;
+            case "--config":
+                options.config = requireValue(argv, ++index, token);
+                break;
+            case "--quiet":
+            case "-q":
+                options.quiet = true;
+                break;
+            case "--version":
+            case "-v":
+                options.version = true;
+                break;
+            case "--help":
+                printHelp();
+                process.exit(0);
+                return options;
+            default:
+                if (token.startsWith("-")) {
+                    throw new Error(`Unknown option: ${token}`);
+                }
+                throw new Error(`Unexpected argument: ${token}`);
+        }
+    }
+    return options;
+}
+function toAnalyzerOptions(options) {
+    return {
+        outputDir: options.outputDir,
+        withDocker: options.withDocker,
+        quiet: options.quiet,
+        html: options.html,
+    };
+}
+function requireValue(argv, index, flag) {
+    const value = argv[index];
+    if (!value || value.startsWith("-")) {
+        throw new Error(`Missing value for ${flag}`);
+    }
+    return value;
+}
+function printHelp() {
+    console.log(`
+Docker Compose Analyzer
+=======================
+
+Usage:
+  npx @deniscuciuc/compose-analyzer [options]
+
+Options:
+  -f, --file <path>          Path to docker-compose file (default: ${constants_1.DEFAULTS.composeFile})
+      --with-docker          Enrich with Docker runtime status when the daemon is available
+      --compare <path>       Compare against a previous JSON report
+      --html                 Also generate an HTML report for full analysis
+  -c, --command <command>    Command to run (default: full)
+  -j, --json                 Output JSON to stdout
+  -o, --output <dir>         Output directory for reports (default: ${constants_1.DEFAULTS.output})
+  -i, --interactive          Interactive menu
+      --config <path>        Path to a config file (non-connection settings only)
+  -q, --quiet                Suppress non-essential log output
+  -v, --version              Print package version
+      --help                 Show this help text
+
+Commands:
+  full
+  health
+  images
+  security
+  reliability
+  resources
+  networks
+
+Notes:
+  - This tool is a static file analyzer. There is no watch mode.
+  - Config support is limited to non-connection settings such as output.
+`);
+}

package/dist/src/cli/runner.d.ts

@@ -0,0 +1,6 @@
+import type { FullComposeReport } from "../types";
+import type { ParsedOptions } from "./options";
+export declare function buildFullReport(options: ParsedOptions): Promise<FullComposeReport>;
+export declare function executeCommand(options: ParsedOptions): Promise<void>;
+export declare function loadPreviousReport(comparePath: string): FullComposeReport;
+//# sourceMappingURL=runner.d.ts.map

package/dist/src/cli/runner.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"runner.d.ts","sourceRoot":"","sources":["../../../src/cli/runner.ts"],"names":[],"mappings":"AAcA,OAAO,KAAK,EAAgB,iBAAiB,EAAkB,MAAM,UAAU,CAAC;AAChF,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,WAAW,CAAC;AAE/C,wBAAsB,eAAe,CACpC,OAAO,EAAE,aAAa,GACpB,OAAO,CAAC,iBAAiB,CAAC,CAqD5B;AAED,wBAAsB,cAAc,CAAC,OAAO,EAAE,aAAa,GAAG,OAAO,CAAC,IAAI,CAAC,CA6D1E;AAED,wBAAgB,kBAAkB,CAAC,WAAW,EAAE,MAAM,GAAG,iBAAiB,CAgBzE"}

package/dist/src/cli/runner.js

@@ -0,0 +1,234 @@
+"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;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildFullReport = buildFullReport;
+exports.executeCommand = executeCommand;
+exports.loadPreviousReport = loadPreviousReport;
+const node_fs_1 = require("node:fs");
+const image_analyzer_1 = require("../analyzers/image-analyzer");
+const network_analyzer_1 = require("../analyzers/network-analyzer");
+const reliability_analyzer_1 = require("../analyzers/reliability-analyzer");
+const resource_analyzer_1 = require("../analyzers/resource-analyzer");
+const security_analyzer_1 = require("../analyzers/security-analyzer");
+const compose_collector_1 = require("../collectors/compose-collector");
+const docker_collector_1 = require("../collectors/docker-collector");
+const constants_1 = require("../constants");
+const health_score_1 = require("../health-score");
+const display = __importStar(require("../interactive/display"));
+const diff_reporter_1 = require("../reporters/diff-reporter");
+const report_generator_1 = require("../reporters/report-generator");
+async function buildFullReport(options) {
+    const collector = new compose_collector_1.ComposeCollector(options.composeFile);
+    const composeFile = collector.getFile();
+    const services = collector.getServices();
+    const images = new image_analyzer_1.ImageAnalyzer().analyze(services);
+    const security = new security_analyzer_1.SecurityAnalyzer().analyze(services);
+    const reliability = new reliability_analyzer_1.ReliabilityAnalyzer().analyze(services);
+    const resources = new resource_analyzer_1.ResourceAnalyzer().analyze(services);
+    const networks = new network_analyzer_1.NetworkAnalyzer().analyze(services, composeFile.networks);
+    const allIssues = sortIssues([
+        ...images.issues,
+        ...security.issues,
+        ...reliability.issues,
+        ...resources.issues,
+        ...networks.issues,
+    ]);
+    const metrics = {
+        totalServices: services.length,
+        servicesWithBuild: services.filter(({ service }) => Boolean(service.build))
+            .length,
+        namedVolumes: Object.keys(composeFile.volumes ?? {}).length,
+        totalIssues: allIssues.length,
+        criticalIssues: allIssues.filter((issue) => issue.severity === "critical")
+            .length,
+        highIssues: allIssues.filter((issue) => issue.severity === "high").length,
+    };
+    const report = {
+        generatedAt: new Date(),
+        composeFile: collector.getFilePath(),
+        version: composeFile.version,
+        healthScore: (0, health_score_1.computeHealthScore)(allIssues, services.length),
+        metrics,
+        images,
+        security,
+        reliability,
+        resources,
+        networks,
+        allIssues,
+        recommendations: buildRecommendations(allIssues),
+    };
+    if (options.withDocker) {
+        report.dockerRuntime = await new docker_collector_1.DockerCollector().collect(services);
+    }
+    return report;
+}
+async function executeCommand(options) {
+    const log = options.quiet || options.json ? () => { } : console.log;
+    const report = await buildFullReport(options);
+    if (options.command !== "full") {
+        const result = buildCommandResult(report, options.command);
+        if (options.json) {
+            console.log(JSON.stringify(result, null, 2));
+            return;
+        }
+        renderCommand(report, options.command);
+        return;
+    }
+    if (options.compare) {
+        const previous = loadPreviousReport(options.compare);
+        diff_reporter_1.DiffReporter.print(diff_reporter_1.DiffReporter.diff(report, previous), options.json ? console.error : console.log);
+    }
+    if (options.json) {
+        console.log(JSON.stringify({
+            success: true,
+            report,
+            summary: {
+                healthScore: report.healthScore,
+                totalServices: report.metrics.totalServices,
+                totalIssues: report.metrics.totalIssues,
+                criticalIssues: report.metrics.criticalIssues,
+                highIssues: report.metrics.highIssues,
+            },
+            recommendations: report.recommendations,
+        }, null, 2));
+        return;
+    }
+    const reporter = new report_generator_1.ReportGenerator(options.outputDir, options);
+    reporter.printSummary(report);
+    log("\nGenerating reports...");
+    const [markdown, json, html] = await Promise.all([
+        reporter.generateFullReport(report),
+        reporter.generateJsonReport(report),
+        options.html ? reporter.generateHtmlReport(report) : undefined,
+    ]);
+    log("\nReports generated:");
+    log(`  - Markdown: ${markdown}`);
+    log(`  - JSON: ${json}`);
+    if (html) {
+        log(`  - HTML: ${html}`);
+    }
+}
+function loadPreviousReport(comparePath) {
+    if (!(0, node_fs_1.existsSync)(comparePath)) {
+        throw new Error(`Compare report not found: ${comparePath}`);
+    }
+    const parsed = JSON.parse((0, node_fs_1.readFileSync)(comparePath, "utf-8"));
+    if (typeof parsed === "object" &&
+        parsed !== null &&
+        "report" in parsed &&
+        parsed.report) {
+        return parsed.report;
+    }
+    return parsed;
+}
+function buildRecommendations(issues) {
+    const seen = new Set();
+    const recommendations = [];
+    for (const issue of issues) {
+        const key = `${issue.service}:${issue.title}`;
+        if (seen.has(key)) {
+            continue;
+        }
+        seen.add(key);
+        recommendations.push({
+            priority: issue.severity,
+            service: issue.service,
+            message: `${issue.title} — ${issue.detail}`,
+            fix: issue.fix,
+        });
+    }
+    return recommendations;
+}
+function sortIssues(issues) {
+    return [...issues].sort((left, right) => {
+        const severityDelta = constants_1.SEVERITY_ORDER[left.severity] - constants_1.SEVERITY_ORDER[right.severity];
+        if (severityDelta !== 0) {
+            return severityDelta;
+        }
+        const serviceDelta = left.service.localeCompare(right.service);
+        if (serviceDelta !== 0) {
+            return serviceDelta;
+        }
+        return left.title.localeCompare(right.title);
+    });
+}
+function buildCommandResult(report, command) {
+    switch (command) {
+        case "health":
+            return {
+                healthScore: report.healthScore,
+                metrics: report.metrics,
+                issues: report.allIssues.map((issue) => `[${issue.severity}] ${issue.service}: ${issue.title}`),
+                recommendations: report.recommendations,
+            };
+        case "images":
+            return report.images;
+        case "security":
+            return report.security;
+        case "reliability":
+            return report.reliability;
+        case "resources":
+            return report.resources;
+        case "networks":
+            return report.networks;
+        default:
+            return report;
+    }
+}
+function renderCommand(report, command) {
+    switch (command) {
+        case "health":
+            display.showHealth(report);
+            break;
+        case "images":
+            display.showImages(report.images);
+            break;
+        case "security":
+            display.showSecurity(report.security);
+            break;
+        case "reliability":
+            display.showReliability(report.reliability);
+            break;
+        case "resources":
+            display.showResources(report.resources);
+            break;
+        case "networks":
+            display.showNetworks(report.networks);
+            break;
+        case "full":
+            display.showFullReportSummary(report);
+            break;
+    }
+}

package/dist/src/collectors/compose-collector.d.ts

@@ -0,0 +1,19 @@
+import type { ComposeFile, ComposeService, NormalizedPort } from "../types";
+export declare class ComposeCollector {
+    private readonly parsed;
+    private readonly filePath;
+    constructor(filePath: string);
+    getFile(): ComposeFile;
+    getFilePath(): string;
+    getServices(): Array<{
+        name: string;
+        service: ComposeService;
+    }>;
+    static baseImageName(image: string): string;
+    static imageTag(image: string): string;
+    static hasDigest(image: string): boolean;
+    static normalizeEnvironment(service: ComposeService): Record<string, string>;
+    static normalizePorts(service: ComposeService): NormalizedPort[];
+    private static parsePortString;
+}
+//# sourceMappingURL=compose-collector.d.ts.map

package/dist/src/collectors/compose-collector.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"compose-collector.d.ts","sourceRoot":"","sources":["../../../src/collectors/compose-collector.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,WAAW,EAAE,cAAc,EAAE,cAAc,EAAE,MAAM,UAAU,CAAC;AAE5E,qBAAa,gBAAgB;IAC5B,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAc;IACrC,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAS;gBAEtB,QAAQ,EAAE,MAAM;IAyB5B,OAAO,IAAI,WAAW;IAItB,WAAW,IAAI,MAAM;IAIrB,WAAW,IAAI,KAAK,CAAC;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,cAAc,CAAA;KAAE,CAAC;IAU/D,MAAM,CAAC,aAAa,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM;IAU3C,MAAM,CAAC,QAAQ,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM;IAWtC,MAAM,CAAC,SAAS,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO;IAIxC,MAAM,CAAC,oBAAoB,CAAC,OAAO,EAAE,cAAc,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC;IAqB5E,MAAM,CAAC,cAAc,CAAC,OAAO,EAAE,cAAc,GAAG,cAAc,EAAE;IAqBhE,OAAO,CAAC,MAAM,CAAC,eAAe;CAuC9B"}

package/dist/src/collectors/compose-collector.js

@@ -0,0 +1,140 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ComposeCollector = void 0;
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+const js_yaml_1 = __importDefault(require("js-yaml"));
+class ComposeCollector {
+    parsed;
+    filePath;
+    constructor(filePath) {
+        const resolved = (0, node_path_1.resolve)(filePath);
+        if (!(0, node_fs_1.existsSync)(resolved)) {
+            throw new Error(`Compose file not found: ${resolved}`);
+        }
+        this.filePath = resolved;
+        try {
+            const loaded = js_yaml_1.default.load((0, node_fs_1.readFileSync)(resolved, "utf-8"));
+            if (!loaded || typeof loaded !== "object") {
+                throw new Error("Compose file is empty or invalid.");
+            }
+            if (!loaded.services || typeof loaded.services !== "object") {
+                throw new Error('No "services" key found in compose file.');
+            }
+            this.parsed = loaded;
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            throw new Error(`Error parsing ${resolved}: ${message}`);
+        }
+    }
+    getFile() {
+        return this.parsed;
+    }
+    getFilePath() {
+        return this.filePath;
+    }
+    getServices() {
+        return Object.entries(this.parsed.services).map(([name, service]) => ({
+            name,
+            service: {
+                ...(service ?? {}),
+                name,
+            },
+        }));
+    }
+    static baseImageName(image) {
+        const reference = image.split("@")[0] ?? image;
+        const lastSlash = reference.lastIndexOf("/");
+        const lastColon = reference.lastIndexOf(":");
+        const withoutTag = lastColon > lastSlash ? reference.slice(0, lastColon) : reference;
+        const parts = withoutTag.split("/");
+        return (parts[parts.length - 1] ?? withoutTag).toLowerCase();
+    }
+    static imageTag(image) {
+        if (ComposeCollector.hasDigest(image)) {
+            return "";
+        }
+        const reference = image.split("@")[0] ?? image;
+        const lastSlash = reference.lastIndexOf("/");
+        const lastColon = reference.lastIndexOf(":");
+        return lastColon > lastSlash ? reference.slice(lastColon + 1) : "";
+    }
+    static hasDigest(image) {
+        return image.includes("@sha256:");
+    }
+    static normalizeEnvironment(service) {
+        const result = {};
+        if (!service.environment) {
+            return result;
+        }
+        if (Array.isArray(service.environment)) {
+            for (const entry of service.environment) {
+                const [key, ...rest] = entry.split("=");
+                result[key] = rest.join("=");
+            }
+            return result;
+        }
+        for (const [key, value] of Object.entries(service.environment)) {
+            result[key] = value ?? "";
+        }
+        return result;
+    }
+    static normalizePorts(service) {
+        const ports = service.ports ?? [];
+        return ports.map((port) => {
+            if (typeof port === "string") {
+                return ComposeCollector.parsePortString(port);
+            }
+            return {
+                raw: `${port.host_ip ? `${port.host_ip}:` : ""}${port.published ? `${port.published}:` : ""}${port.target}${port.protocol ? `/${port.protocol}` : ""}`,
+                hostIp: port.host_ip,
+                published: port.published?.toString(),
+                target: port.target.toString(),
+                protocol: port.protocol ?? "tcp",
+                exposesToAllInterfaces: port.published !== undefined &&
+                    (!port.host_ip || port.host_ip === "0.0.0.0"),
+                randomHostBinding: port.published === undefined,
+            };
+        });
+    }
+    static parsePortString(value) {
+        const [body, protocol = "tcp"] = value.split("/");
+        const parts = body.split(":");
+        if (parts.length === 1) {
+            return {
+                raw: value,
+                target: parts[0],
+                protocol,
+                exposesToAllInterfaces: true,
+                randomHostBinding: true,
+            };
+        }
+        if (parts.length === 2) {
+            return {
+                raw: value,
+                published: parts[0],
+                target: parts[1],
+                protocol,
+                exposesToAllInterfaces: true,
+                randomHostBinding: false,
+            };
+        }
+        const hostIp = parts.slice(0, -2).join(":");
+        const published = parts.at(-2) ?? "";
+        const target = parts.at(-1) ?? "";
+        return {
+            raw: value,
+            hostIp,
+            published,
+            target,
+            protocol,
+            exposesToAllInterfaces: hostIp === "" || hostIp === "0.0.0.0",
+            randomHostBinding: false,
+        };
+    }
+}
+exports.ComposeCollector = ComposeCollector;

package/dist/src/collectors/docker-collector.d.ts

@@ -0,0 +1,8 @@
+import type { ComposeService, DockerRuntimeSummary } from "../types";
+export declare class DockerCollector {
+    collect(services: Array<{
+        name: string;
+        service: ComposeService;
+    }>): Promise<DockerRuntimeSummary>;
+}
+//# sourceMappingURL=docker-collector.d.ts.map

package/dist/src/collectors/docker-collector.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"docker-collector.d.ts","sourceRoot":"","sources":["../../../src/collectors/docker-collector.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACX,cAAc,EAEd,oBAAoB,EACpB,MAAM,UAAU,CAAC;AAElB,qBAAa,eAAe;IACrB,OAAO,CACZ,QAAQ,EAAE,KAAK,CAAC;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,cAAc,CAAA;KAAE,CAAC,GACxD,OAAO,CAAC,oBAAoB,CAAC;CA6DhC"}