@companyhelm/cli 0.4.1 → 0.4.3

package/dist/core/runtime/PublicImageTagRegistry.js

@@ -1,168 +0,0 @@
-import { buildManagedImageReference, getManagedImageDefinition } from "./ManagedImages.js";
-const RETRYABLE_STATUS_CODES = new Set([429, 500, 502, 503, 504]);
-const MAX_FETCH_ATTEMPTS = 3;
-const DEFAULT_RETRY_DELAY_MS = 250;
-const METADATA_FETCH_CONCURRENCY = 6;
-class PublicRegistryRequestError extends Error {
-    status;
-    retryAfterMs;
-    constructor(url, status, retryAfterMs) {
-        super(`Public registry returned ${status} for ${url}.`);
-        this.status = status;
-        this.retryAfterMs = retryAfterMs;
-    }
-}
-export class PublicImageTagRegistry {
-    async listAvailableTags(service, limit = 20) {
-        if (!Number.isInteger(limit) || limit < 1) {
-            throw new Error("Image tag limit must be a positive integer.");
-        }
-        const { repositoryPath } = getManagedImageDefinition(service);
-        const token = await this.fetchToken(repositoryPath);
-        const response = await fetch(`https://public.ecr.aws/v2/${repositoryPath}/tags/list`, {
-            headers: {
-                Authorization: `Bearer ${token}`
-            }
-        });
-        if (!response.ok) {
-            throw new Error(`Public registry returned ${response.status} for ${service} tags.`);
-        }
-        const payload = (await response.json());
-        if (payload.errors?.length) {
-            throw new Error(payload.errors[0]?.message || `Unable to load ${service} image tags.`);
-        }
-        const uniqueTags = [...new Set(payload.tags ?? [])].map((tag, position) => ({ tag, position }));
-        const candidateTags = uniqueTags.slice(0, limit);
-        const createdAtByDigest = new Map();
-        const tagsWithMetadata = await this.mapWithConcurrency(candidateTags, METADATA_FETCH_CONCURRENCY, async ({ tag, position }) => ({
-            tag,
-            position,
-            createdAt: await this.fetchCreatedAt(repositoryPath, token, tag, createdAtByDigest)
-        }));
-        return tagsWithMetadata
-            .sort((left, right) => {
-            const leftTimestamp = left.createdAt ? Date.parse(left.createdAt) : Number.NEGATIVE_INFINITY;
-            const rightTimestamp = right.createdAt ? Date.parse(right.createdAt) : Number.NEGATIVE_INFINITY;
-            if (rightTimestamp !== leftTimestamp) {
-                return rightTimestamp - leftTimestamp;
-            }
-            return left.position - right.position;
-        })
-            .map(({ tag, createdAt }) => ({ tag, createdAt }));
-    }
-    buildImageReference(service, tag) {
-        return buildManagedImageReference(service, tag);
-    }
-    async fetchToken(repositoryPath) {
-        const scope = `repository:${repositoryPath}:pull`;
-        const response = await fetch(`https://public.ecr.aws/token/?service=public.ecr.aws&scope=${encodeURIComponent(scope)}`);
-        if (!response.ok) {
-            throw new Error(`Public registry token request returned ${response.status}.`);
-        }
-        const payload = (await response.json());
-        if (!payload.token) {
-            throw new Error("Public registry token response did not include a token.");
-        }
-        return payload.token;
-    }
-    async fetchCreatedAt(repositoryPath, token, tag, createdAtByDigest) {
-        try {
-            const manifestReference = await this.fetchJson(`https://public.ecr.aws/v2/${repositoryPath}/manifests/${encodeURIComponent(tag)}`, {
-                Authorization: `Bearer ${token}`,
-                Accept: [
-                    "application/vnd.oci.image.index.v1+json",
-                    "application/vnd.docker.distribution.manifest.list.v2+json",
-                    "application/vnd.oci.image.manifest.v1+json",
-                    "application/vnd.docker.distribution.manifest.v2+json"
-                ].join(", ")
-            });
-            const digest = this.selectManifestDigest(manifestReference);
-            const manifest = digest
-                ? await this.fetchJson(`https://public.ecr.aws/v2/${repositoryPath}/manifests/${encodeURIComponent(digest)}`, {
-                    Authorization: `Bearer ${token}`,
-                    Accept: ["application/vnd.oci.image.manifest.v1+json", "application/vnd.docker.distribution.manifest.v2+json"].join(", ")
-                })
-                : manifestReference;
-            const configDigest = "config" in manifest ? manifest.config?.digest : undefined;
-            if (!configDigest) {
-                return undefined;
-            }
-            const existingCreatedAt = createdAtByDigest.get(configDigest);
-            if (existingCreatedAt) {
-                return await existingCreatedAt;
-            }
-            const createdAtPromise = this.fetchJson(`https://public.ecr.aws/v2/${repositoryPath}/blobs/${configDigest}`, {
-                Authorization: `Bearer ${token}`
-            })
-                .then((config) => config.created)
-                .catch((error) => {
-                createdAtByDigest.delete(configDigest);
-                throw error;
-            });
-            createdAtByDigest.set(configDigest, createdAtPromise);
-            return await createdAtPromise;
-        }
-        catch (error) {
-            if (error instanceof PublicRegistryRequestError) {
-                return undefined;
-            }
-            throw error;
-        }
-    }
-    selectManifestDigest(manifest) {
-        if (!("manifests" in manifest) || !manifest.manifests?.length) {
-            return undefined;
-        }
-        return (manifest.manifests.find((entry) => entry.platform?.os === "linux" && entry.platform?.architecture === "amd64")
-            ?.digest ?? manifest.manifests[0]?.digest);
-    }
-    async fetchJson(url, headers) {
-        for (let attempt = 1; attempt <= MAX_FETCH_ATTEMPTS; attempt += 1) {
-            const response = await fetch(url, { headers });
-            if (response.ok) {
-                return (await response.json());
-            }
-            const retryAfterMs = this.parseRetryAfterMs(response);
-            if (attempt < MAX_FETCH_ATTEMPTS && RETRYABLE_STATUS_CODES.has(response.status)) {
-                await this.sleep(retryAfterMs ?? DEFAULT_RETRY_DELAY_MS * attempt);
-                continue;
-            }
-            throw new PublicRegistryRequestError(url, response.status, retryAfterMs);
-        }
-        throw new PublicRegistryRequestError(url, 500);
-    }
-    parseRetryAfterMs(response) {
-        const retryAfter = response.headers.get("retry-after");
-        if (!retryAfter) {
-            return undefined;
-        }
-        const retryAfterSeconds = Number.parseInt(retryAfter, 10);
-        if (Number.isFinite(retryAfterSeconds)) {
-            return Math.max(retryAfterSeconds, 0) * 1000;
-        }
-        const retryAt = Date.parse(retryAfter);
-        if (Number.isNaN(retryAt)) {
-            return undefined;
-        }
-        return Math.max(retryAt - Date.now(), 0);
-    }
-    async sleep(delayMs) {
-        await new Promise((resolve) => setTimeout(resolve, delayMs));
-    }
-    async mapWithConcurrency(items, concurrency, mapper) {
-        if (items.length === 0) {
-            return [];
-        }
-        const results = new Array(items.length);
-        let nextIndex = 0;
-        const workerCount = Math.min(concurrency, items.length);
-        await Promise.all(Array.from({ length: workerCount }, async () => {
-            while (nextIndex < items.length) {
-                const currentIndex = nextIndex;
-                nextIndex += 1;
-                results[currentIndex] = await mapper(items[currentIndex], currentIndex);
-            }
-        }));
-        return results;
-    }
-}

package/dist/core/runtime/RuntimePaths.d.ts

@@ -1,16 +0,0 @@
-export declare class RuntimePaths {
-    private readonly root;
-    constructor(root: string);
-    stateFilePath(): string;
-    composeFilePath(): string;
-    apiDirectoryPath(): string;
-    apiEnvPath(): string;
-    apiConfigPath(): string;
-    frontendConfigPath(): string;
-    seedFilePath(): string;
-    runnerConfigPath(): string;
-    runnerStateDbPath(): string;
-    runnerLogPath(): string;
-    serviceRuntimePath(): string;
-    serviceLogPath(service: "api" | "frontend"): string;
-}

package/dist/core/runtime/RuntimePaths.js

@@ -1,43 +0,0 @@
-import path from "node:path";
-export class RuntimePaths {
-    root;
-    constructor(root) {
-        this.root = root;
-    }
-    stateFilePath() {
-        return path.join(this.root, "state.yaml");
-    }
-    composeFilePath() {
-        return path.join(this.root, "docker-compose.yaml");
-    }
-    apiDirectoryPath() {
-        return path.join(this.root, "api");
-    }
-    apiEnvPath() {
-        return path.join(this.apiDirectoryPath(), ".env");
-    }
-    apiConfigPath() {
-        return path.join(this.root, "api-config.yaml");
-    }
-    frontendConfigPath() {
-        return path.join(this.root, "frontend-config.yaml");
-    }
-    seedFilePath() {
-        return path.join(this.root, "seed.sql");
-    }
-    runnerConfigPath() {
-        return path.join(this.root, "runner");
-    }
-    runnerStateDbPath() {
-        return path.join(this.runnerConfigPath(), "state.db");
-    }
-    runnerLogPath() {
-        return path.join(this.runnerConfigPath(), "daemon.log");
-    }
-    serviceRuntimePath() {
-        return path.join(this.root, "services");
-    }
-    serviceLogPath(service) {
-        return path.join(this.serviceRuntimePath(), `${service}.log`);
-    }
-}

package/dist/core/runtime/RuntimeState.d.ts

@@ -1,38 +0,0 @@
-export interface RuntimePorts {
-    apiHttp: number;
-    ui: number;
-    runnerGrpc: number;
-    agentCliGrpc: number;
-}
-export interface DockerManagedServiceRuntime {
-    source: "docker";
-}
-export interface LocalManagedServiceRuntime {
-    source: "local";
-    repoPath: string;
-    logPath: string;
-    pid: number;
-}
-export type ManagedServiceRuntime = DockerManagedServiceRuntime | LocalManagedServiceRuntime;
-export interface RuntimeState {
-    version: 1;
-    company: {
-        id: string;
-        name: string;
-    };
-    auth: {
-        username: string;
-        password: string;
-        jwtPrivateKeyPem: string;
-        jwtPublicKeyPem: string;
-    };
-    runner: {
-        name: string;
-        secret: string;
-    };
-    ports: RuntimePorts;
-    services: {
-        api: ManagedServiceRuntime;
-        frontend: ManagedServiceRuntime;
-    };
-}

package/dist/core/runtime/RuntimeState.js

@@ -1 +0,0 @@
-export {};

package/dist/core/runtime/RuntimeStateStore.d.ts

@@ -1,11 +0,0 @@
-import type { RuntimeState } from "./RuntimeState.js";
-export declare class RuntimeStateStore {
-    private readonly root;
-    private readonly runtimePaths;
-    private static readonly DEFAULT_USERNAME;
-    constructor(root: string);
-    initialize(): RuntimeState;
-    load(): RuntimeState | null;
-    persist(state: RuntimeState): void;
-    private save;
-}

package/dist/core/runtime/RuntimeStateStore.js

@@ -1,81 +0,0 @@
-import fs from "node:fs";
-import YAML from "yaml";
-import { PortAllocator } from "./PortAllocator.js";
-import { RuntimePaths } from "./RuntimePaths.js";
-import { createPemKeyPair, randomCompanyId, randomSecret } from "./Secrets.js";
-export class RuntimeStateStore {
-    root;
-    runtimePaths;
-    static DEFAULT_USERNAME = "admin@local";
-    constructor(root) {
-        this.root = root;
-        this.runtimePaths = new RuntimePaths(root);
-    }
-    initialize() {
-        const existingState = this.load();
-        if (existingState) {
-            return existingState;
-        }
-        fs.mkdirSync(this.root, { recursive: true });
-        const authKeys = createPemKeyPair();
-        const state = {
-            version: 1,
-            company: {
-                id: randomCompanyId(),
-                name: "Local CompanyHelm"
-            },
-            auth: {
-                username: RuntimeStateStore.DEFAULT_USERNAME,
-                password: randomSecret(),
-                jwtPrivateKeyPem: authKeys.privateKeyPem,
-                jwtPublicKeyPem: authKeys.publicKeyPem
-            },
-            runner: {
-                name: "local-runner",
-                secret: randomSecret()
-            },
-            ports: new PortAllocator().allocate(),
-            services: {
-                api: {
-                    source: "docker"
-                },
-                frontend: {
-                    source: "docker"
-                }
-            }
-        };
-        this.save(state);
-        return state;
-    }
-    load() {
-        if (!fs.existsSync(this.runtimePaths.stateFilePath())) {
-            return null;
-        }
-        const state = YAML.parse(fs.readFileSync(this.runtimePaths.stateFilePath(), "utf8"));
-        if (state.auth.username !== RuntimeStateStore.DEFAULT_USERNAME && state.auth.username === "admin") {
-            state.auth.username = RuntimeStateStore.DEFAULT_USERNAME;
-            this.save(state);
-        }
-        if (!state.services) {
-            state.services = {
-                api: {
-                    source: "docker"
-                },
-                frontend: {
-                    source: "docker"
-                }
-            };
-            this.save(state);
-        }
-        return state;
-    }
-    persist(state) {
-        this.save(state);
-    }
-    save(state) {
-        fs.writeFileSync(this.runtimePaths.stateFilePath(), YAML.stringify(state), {
-            encoding: "utf8",
-            mode: 0o600
-        });
-    }
-}

package/dist/core/runtime/Secrets.d.ts

@@ -1,10 +0,0 @@
-export declare function randomSecret(length?: number): string;
-export declare function randomCompanyId(): string;
-export declare function createPasswordHash(password: string): {
-    passwordSalt: string;
-    passwordHash: string;
-};
-export declare function createPemKeyPair(): {
-    privateKeyPem: string;
-    publicKeyPem: string;
-};

package/dist/core/runtime/Secrets.js

@@ -1,26 +0,0 @@
-import { generateKeyPairSync, randomBytes, randomUUID, scryptSync } from "node:crypto";
-export function randomSecret(length = 24) {
-    return randomBytes(length).toString("base64url");
-}
-export function randomCompanyId() {
-    return randomUUID();
-}
-export function createPasswordHash(password) {
-    const passwordSalt = randomBytes(16).toString("hex");
-    const passwordHash = scryptSync(password, passwordSalt, 64).toString("hex");
-    return {
-        passwordSalt,
-        passwordHash
-    };
-}
-export function createPemKeyPair() {
-    const { privateKey, publicKey } = generateKeyPairSync("rsa", {
-        modulusLength: 2048,
-        privateKeyEncoding: { format: "pem", type: "pkcs1" },
-        publicKeyEncoding: { format: "pem", type: "pkcs1" }
-    });
-    return {
-        privateKeyPem: privateKey,
-        publicKeyPem: publicKey
-    };
-}

package/dist/core/runtime/VersionCatalog.d.ts

@@ -1,10 +0,0 @@
-import { type RuntimeImages } from "./ImageCatalog.js";
-export interface RuntimeVersions {
-    cliPackage: string;
-    runnerPackage: string;
-    images: RuntimeImages;
-}
-export declare class VersionCatalog {
-    resolve(): RuntimeVersions;
-    private readPackageVersion;
-}

package/dist/core/runtime/VersionCatalog.js

@@ -1,21 +0,0 @@
-import fs from "node:fs";
-import path from "node:path";
-import { createRequire } from "node:module";
-import { fileURLToPath } from "node:url";
-import { ImageCatalog } from "./ImageCatalog.js";
-const require = createRequire(import.meta.url);
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = path.dirname(__filename);
-export class VersionCatalog {
-    resolve() {
-        return {
-            cliPackage: this.readPackageVersion(path.resolve(__dirname, "../../../package.json")),
-            runnerPackage: this.readPackageVersion(require.resolve("@companyhelm/runner/package.json")),
-            images: new ImageCatalog().resolve()
-        };
-    }
-    readPackageVersion(packageJsonPath) {
-        const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, "utf8"));
-        return `${packageJson.name}@${packageJson.version}`;
-    }
-}

package/dist/core/services/ManagedServiceNames.d.ts

@@ -1,5 +0,0 @@
-export declare const MANAGED_SERVICE_KEYS: readonly ["postgres", "api", "frontend", "runner"];
-export type ManagedServiceKey = (typeof MANAGED_SERVICE_KEYS)[number];
-export declare const MANAGED_SERVICE_NAMES: Record<ManagedServiceKey, string>;
-export declare const AVAILABLE_MANAGED_SERVICE_NAMES: string[];
-export declare function resolveManagedServiceKey(serviceName: string): ManagedServiceKey | null;

package/dist/core/services/ManagedServiceNames.js

@@ -1,12 +0,0 @@
-export const MANAGED_SERVICE_KEYS = ["postgres", "api", "frontend", "runner"];
-export const MANAGED_SERVICE_NAMES = {
-    postgres: "postgres",
-    api: "companyhelm-api",
-    frontend: "companyhelm-web",
-    runner: "companyhelm-runner"
-};
-const SERVICE_NAME_TO_KEY = new Map(Object.entries(MANAGED_SERVICE_NAMES).map(([key, value]) => [value, key]));
-export const AVAILABLE_MANAGED_SERVICE_NAMES = MANAGED_SERVICE_KEYS.map((key) => MANAGED_SERVICE_NAMES[key]);
-export function resolveManagedServiceKey(serviceName) {
-    return SERVICE_NAME_TO_KEY.get(serviceName.trim()) ?? null;
-}

package/dist/core/status/StatusService.d.ts

@@ -1,19 +0,0 @@
-export type ManagedServiceStatus = "running" | "stopped";
-export interface StatusSnapshot {
-    postgres: ManagedServiceStatus;
-    api: ManagedServiceStatus;
-    frontend: ManagedServiceStatus;
-    runner: ManagedServiceStatus;
-}
-export interface StatusOverrides {
-    api?: () => Promise<boolean | undefined> | boolean | undefined;
-    frontend?: () => Promise<boolean | undefined> | boolean | undefined;
-    runner?: () => Promise<boolean | undefined> | boolean | undefined;
-}
-export declare class StatusService {
-    private readonly listRunningServices;
-    private readonly overrides;
-    constructor(listRunningServices: () => Promise<string>, overrides?: StatusOverrides);
-    read(): Promise<StatusSnapshot>;
-    private resolveServiceRunning;
-}

package/dist/core/status/StatusService.js

@@ -1,30 +0,0 @@
-export class StatusService {
-    listRunningServices;
-    overrides;
-    constructor(listRunningServices, overrides = {}) {
-        this.listRunningServices = listRunningServices;
-        this.overrides = overrides;
-    }
-    async read() {
-        const running = new Set((await this.listRunningServices())
-            .split("\n")
-            .map((service) => service.trim())
-            .filter(Boolean));
-        const apiRunning = await this.resolveServiceRunning("api", this.overrides.api, running);
-        const frontendRunning = await this.resolveServiceRunning("frontend", this.overrides.frontend, running);
-        const runnerRunning = await this.resolveServiceRunning("runner", this.overrides.runner, running);
-        return {
-            postgres: running.has("postgres") ? "running" : "stopped",
-            api: apiRunning ? "running" : "stopped",
-            frontend: frontendRunning ? "running" : "stopped",
-            runner: runnerRunning ? "running" : "stopped"
-        };
-    }
-    async resolveServiceRunning(service, override, running) {
-        if (!override) {
-            return running.has(service);
-        }
-        const result = await override();
-        return typeof result === "boolean" ? result : running.has(service);
-    }
-}

package/dist/core/ui/TerminalRenderer.d.ts

@@ -1,17 +0,0 @@
-import type { StatusReport } from "../../commands/dependencies.js";
-export declare class TerminalRenderer {
-    private readonly useColor;
-    private static readonly OSC;
-    private static readonly BEL;
-    constructor(useColor?: boolean);
-    renderBanner(): string;
-    success(message: string): string;
-    progress(message: string): string;
-    successHighlight(message: string): string;
-    clickableUrl(url: string): string;
-    renderStatus(report: StatusReport): string;
-    private renderServiceLine;
-    private warn;
-    private formatDetail;
-    private colorize;
-}

package/dist/core/ui/TerminalRenderer.js

@@ -1,71 +0,0 @@
-import chalk from "chalk";
-import figlet from "figlet";
-export class TerminalRenderer {
-    useColor;
-    static OSC = "\u001B]";
-    static BEL = "\u0007";
-    constructor(useColor = true) {
-        this.useColor = useColor;
-    }
-    renderBanner() {
-        const banner = figlet.textSync("COMPANYHELM", {
-            horizontalLayout: "fitted"
-        });
-        return this.colorize(`COMPANYHELM\n${banner}`, "cyan");
-    }
-    success(message) {
-        return `${this.colorize("[ok]", "green")} ${message}`;
-    }
-    progress(message) {
-        return this.colorize(`... ${message}`, "cyan");
-    }
-    successHighlight(message) {
-        if (!this.useColor) {
-            return message;
-        }
-        return chalk.green.bold(message);
-    }
-    clickableUrl(url) {
-        if (!this.useColor) {
-            return url;
-        }
-        const display = this.successHighlight(url);
-        return `${TerminalRenderer.OSC}8;;${url}${TerminalRenderer.BEL}${display}${TerminalRenderer.OSC}8;;${TerminalRenderer.BEL}`;
-    }
-    renderStatus(report) {
-        const lines = ["Status"];
-        lines.push(this.renderServiceLine("Postgres", report.services.postgres));
-        lines.push(this.renderServiceLine("API", report.services.api, report.apiUrl));
-        lines.push(this.renderServiceLine("companyhelm-web", report.services.frontend, report.uiUrl));
-        lines.push(this.renderServiceLine("Runner", report.services.runner));
-        if (report.versions) {
-            lines.push(`CompanyHelm CLI: ${report.versions.cliPackage}`);
-            lines.push(`Runner package: ${report.versions.runnerPackage}`);
-            lines.push(`API image: ${report.versions.images.api}`);
-            lines.push(`companyhelm-web image: ${report.versions.images.frontend}`);
-            lines.push(`Postgres image: ${report.versions.images.postgres}`);
-        }
-        if (report.username) {
-            lines.push(`username: ${report.username}`);
-        }
-        return lines.join("\n");
-    }
-    renderServiceLine(label, status, detail) {
-        const statusLabel = status === "running" ? this.success("running") : this.warn("stopped");
-        return detail && status === "running"
-            ? `${label}: ${statusLabel} (${this.formatDetail(detail)})`
-            : `${label}: ${statusLabel}`;
-    }
-    warn(message) {
-        return `${this.colorize("[!]", "yellow")} ${message}`;
-    }
-    formatDetail(detail) {
-        return detail.startsWith("http://") || detail.startsWith("https://") ? this.clickableUrl(detail) : detail;
-    }
-    colorize(text, color) {
-        if (!this.useColor) {
-            return text;
-        }
-        return chalk[color](text);
-    }
-}

package/dist/preflight/ApiPortPreflightCheck.d.ts

@@ -1,6 +0,0 @@
-import type { PreflightCheck } from "./PreflightCheck.js";
-export declare class ApiPortPreflightCheck implements PreflightCheck {
-    private readonly delegate;
-    constructor(port: number);
-    run(): Promise<void>;
-}

package/dist/preflight/ApiPortPreflightCheck.js

@@ -1,10 +0,0 @@
-import { PortAvailabilityPreflightCheck } from "./PortAvailabilityPreflightCheck.js";
-export class ApiPortPreflightCheck {
-    delegate;
-    constructor(port) {
-        this.delegate = new PortAvailabilityPreflightCheck("companyhelm-api", port);
-    }
-    run() {
-        return this.delegate.run();
-    }
-}

package/dist/preflight/DockerInstalledPreflightCheck.d.ts

@@ -1,7 +0,0 @@
-import { CommandRunner } from "../core/process/CommandRunner.js";
-import type { PreflightCheck } from "./PreflightCheck.js";
-export declare class DockerInstalledPreflightCheck implements PreflightCheck {
-    private readonly commandRunner;
-    constructor(commandRunner?: CommandRunner);
-    run(): Promise<void>;
-}

package/dist/preflight/DockerInstalledPreflightCheck.js

@@ -1,15 +0,0 @@
-import { CommandRunner } from "../core/process/CommandRunner.js";
-export class DockerInstalledPreflightCheck {
-    commandRunner;
-    constructor(commandRunner = new CommandRunner()) {
-        this.commandRunner = commandRunner;
-    }
-    async run() {
-        try {
-            await this.commandRunner.capture("docker", ["--version"]);
-        }
-        catch {
-            throw new Error("Docker is required for `companyhelm up`, but the `docker` command is unavailable. Install Docker and make sure it is on your PATH.");
-        }
-    }
-}

package/dist/preflight/PortAvailabilityPreflightCheck.d.ts

@@ -1,7 +0,0 @@
-import type { PreflightCheck } from "./PreflightCheck.js";
-export declare class PortAvailabilityPreflightCheck implements PreflightCheck {
-    private readonly serviceName;
-    private readonly port;
-    constructor(serviceName: string, port: number);
-    run(): Promise<void>;
-}