@companyhelm/cli 0.1.2 → 0.1.5

package/dist/core/runner/RunnerSupervisor.js

@@ -1,20 +1,31 @@
 import path from "node:path";
 import { createRequire } from "node:module";
 const require = createRequire(import.meta.url);
+const DEFAULT_HOST_DOCKER_PATH = "unix:///var/run/docker.sock";
 export class RunnerSupervisor {
     configPath;
     constructor(configPath) {
         this.configPath = configPath;
     }
+    buildUseHostAuthArgs() {
+        const runnerCliPath = this.resolveRunnerCliPath();
+        return {
+            command: process.execPath,
+            args: [runnerCliPath, "--config-path", this.configPath, "sdk", "codex", "use-host-auth"]
+        };
+    }
     buildStartArgs(input) {
         const runnerCliPath = this.resolveRunnerCliPath();
+        const logLevel = (input.logLevel ?? "info").toUpperCase();
+        const hostDockerArgs = input.useHostDockerRuntime
+            ? ["--use-host-docker-runtime", "--host-docker-path", this.resolveHostDockerPath()]
+            : [];
         return {
             command: process.execPath,
             args: [
                 runnerCliPath,
                 "--config-path",
                 this.configPath,
-                "runner",
                 "start",
                 "--daemon",
                 "--server-url",
@@ -23,8 +34,11 @@ export class RunnerSupervisor {
                 input.agentApiUrl,
                 "--log-path",
                 input.logPath,
+                ...hostDockerArgs,
                 "--secret",
-                input.secret
+                input.secret,
+                "--log-level",
+                logLevel
             ]
         };
     }
@@ -32,7 +46,14 @@ export class RunnerSupervisor {
         const runnerCliPath = this.resolveRunnerCliPath();
         return {
             command: process.execPath,
-            args: [runnerCliPath, "--config-path", this.configPath, "runner", "stop"]
+            args: [runnerCliPath, "--config-path", this.configPath, "stop"]
+        };
+    }
+    buildStatusArgs() {
+        const runnerCliPath = this.resolveRunnerCliPath();
+        return {
+            command: process.execPath,
+            args: [runnerCliPath, "--config-path", this.configPath, "status"]
         };
     }
     resolveRunnerCliPath() {
@@ -42,4 +63,11 @@ export class RunnerSupervisor {
         const packageJsonPath = require.resolve("@companyhelm/runner/package.json");
         return path.resolve(path.dirname(packageJsonPath), "dist/cli.js");
     }
+    resolveHostDockerPath() {
+        const dockerHost = String(process.env.DOCKER_HOST || "").trim();
+        if (dockerHost) {
+            return dockerHost;
+        }
+        return DEFAULT_HOST_DOCKER_PATH;
+    }
 }

package/dist/core/runtime/ImageCatalog.js

@@ -1,8 +1,11 @@
+import { LocalConfigStore } from "./LocalConfigStore.js";
+import { defaultManagedImageReference } from "./ManagedImages.js";
 export class ImageCatalog {
     resolve() {
+        const configuredImages = new LocalConfigStore().load().images;
         return {
-            api: process.env.COMPANYHELM_API_IMAGE || "companyhelm-api:latest",
-            frontend: process.env.COMPANYHELM_WEB_IMAGE || "companyhelm-web:latest",
+            api: configuredImages.api || process.env.COMPANYHELM_API_IMAGE || defaultManagedImageReference("api"),
+            frontend: configuredImages.frontend || process.env.COMPANYHELM_WEB_IMAGE || defaultManagedImageReference("frontend"),
             postgres: process.env.COMPANYHELM_POSTGRES_IMAGE || "postgres:16-alpine"
         };
     }

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

@@ -0,0 +1,16 @@
+import type { ManagedImageService } from "./ManagedImages.js";
+export interface LocalConfig {
+    images: Partial<Record<ManagedImageService, string>>;
+}
+export declare class LocalConfigStore {
+    private readonly root;
+    constructor(root?: string);
+    configPath(): string;
+    load(): LocalConfig;
+    setImage(service: ManagedImageService, image: string): {
+        configPath: string;
+        image: string;
+    };
+    save(config: LocalConfig): void;
+    private parse;
+}

package/dist/core/runtime/LocalConfigStore.js

@@ -0,0 +1,59 @@
+import fs from "node:fs";
+import path from "node:path";
+export class LocalConfigStore {
+    root;
+    constructor(root = process.cwd()) {
+        this.root = root;
+    }
+    configPath() {
+        return path.join(this.root, "config.yaml");
+    }
+    load() {
+        const configPath = this.configPath();
+        if (!fs.existsSync(configPath)) {
+            return { images: {} };
+        }
+        return this.parse(fs.readFileSync(configPath, "utf8"));
+    }
+    setImage(service, image) {
+        const nextConfig = this.load();
+        nextConfig.images[service] = image;
+        this.save(nextConfig);
+        return { configPath: this.configPath(), image };
+    }
+    save(config) {
+        const lines = ["images:"];
+        if (config.images.api) {
+            lines.push(`  api: ${config.images.api}`);
+        }
+        if (config.images.frontend) {
+            lines.push(`  frontend: ${config.images.frontend}`);
+        }
+        fs.writeFileSync(this.configPath(), `${lines.join("\n")}\n`, "utf8");
+    }
+    parse(content) {
+        const images = {};
+        let inImagesSection = false;
+        for (const rawLine of content.split(/\r?\n/)) {
+            const line = rawLine.trimEnd();
+            if (line.trim().length === 0 || line.trimStart().startsWith("#")) {
+                continue;
+            }
+            if (line === "images:") {
+                inImagesSection = true;
+                continue;
+            }
+            if (inImagesSection && /^[^\s]/.test(line)) {
+                inImagesSection = false;
+            }
+            if (!inImagesSection) {
+                continue;
+            }
+            const match = line.match(/^  (api|frontend):\s*(.+)$/);
+            if (match) {
+                images[match[1]] = match[2];
+            }
+        }
+        return { images };
+    }
+}

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

@@ -0,0 +1,10 @@
+export declare const MANAGED_IMAGE_SERVICES: readonly ["api", "frontend"];
+export type ManagedImageService = (typeof MANAGED_IMAGE_SERVICES)[number];
+export interface ManagedImageDefinition {
+    imageUri: string;
+    repositoryPath: string;
+}
+export declare function requireManagedImageService(value: string): ManagedImageService;
+export declare function getManagedImageDefinition(service: ManagedImageService): ManagedImageDefinition;
+export declare function buildManagedImageReference(service: ManagedImageService, tag: string): string;
+export declare function defaultManagedImageReference(service: ManagedImageService): string;

package/dist/core/runtime/ManagedImages.js

@@ -0,0 +1,27 @@
+export const MANAGED_IMAGE_SERVICES = ["api", "frontend"];
+const MANAGED_IMAGE_DEFINITIONS = {
+    api: {
+        imageUri: "public.ecr.aws/x6n0f2k4/companyhelm-api",
+        repositoryPath: "x6n0f2k4/companyhelm-api"
+    },
+    frontend: {
+        imageUri: "public.ecr.aws/x6n0f2k4/companyhelm-web",
+        repositoryPath: "x6n0f2k4/companyhelm-web"
+    }
+};
+export function requireManagedImageService(value) {
+    const normalized = value.trim().toLowerCase();
+    if (normalized === "api" || normalized === "frontend") {
+        return normalized;
+    }
+    throw new Error(`Unsupported image service "${value}". Expected one of: api, frontend.`);
+}
+export function getManagedImageDefinition(service) {
+    return MANAGED_IMAGE_DEFINITIONS[service];
+}
+export function buildManagedImageReference(service, tag) {
+    return `${MANAGED_IMAGE_DEFINITIONS[service].imageUri}:${tag}`;
+}
+export function defaultManagedImageReference(service) {
+    return buildManagedImageReference(service, "latest");
+}

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

@@ -0,0 +1,7 @@
+export declare class ProjectPaths {
+    private readonly root;
+    constructor(root?: string);
+    companyhelmRootPath(): string;
+    apiDirectoryPath(): string;
+    apiEnvPath(): string;
+}

package/dist/core/runtime/ProjectPaths.js

@@ -0,0 +1,16 @@
+import path from "node:path";
+export class ProjectPaths {
+    root;
+    constructor(root = process.cwd()) {
+        this.root = root;
+    }
+    companyhelmRootPath() {
+        return path.join(this.root, ".companyhelm");
+    }
+    apiDirectoryPath() {
+        return path.join(this.companyhelmRootPath(), "api");
+    }
+    apiEnvPath() {
+        return path.join(this.apiDirectoryPath(), ".env");
+    }
+}

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

@@ -0,0 +1,16 @@
+import { type ManagedImageService } from "./ManagedImages.js";
+interface PublicRegistryImageTag {
+    tag: string;
+    createdAt?: string;
+}
+export declare class PublicImageTagRegistry {
+    listAvailableTags(service: ManagedImageService, limit?: number): Promise<PublicRegistryImageTag[]>;
+    buildImageReference(service: ManagedImageService, tag: string): string;
+    private fetchToken;
+    private fetchCreatedAt;
+    private selectManifestDigest;
+    private fetchJson;
+    private parseRetryAfterMs;
+    private sleep;
+}
+export {};

package/dist/core/runtime/PublicImageTagRegistry.js

@@ -0,0 +1,148 @@
+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;
+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 createdAtByDigest = new Map();
+        const tagsWithMetadata = [];
+        for (const { tag, position } of uniqueTags) {
+            tagsWithMetadata.push({
+                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;
+        })
+            .slice(0, limit)
+            .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;
+            }
+            if (createdAtByDigest.has(configDigest)) {
+                return createdAtByDigest.get(configDigest);
+            }
+            const config = await this.fetchJson(`https://public.ecr.aws/v2/${repositoryPath}/blobs/${configDigest}`, {
+                Authorization: `Bearer ${token}`
+            });
+            createdAtByDigest.set(configDigest, config.created);
+            return config.created;
+        }
+        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));
+    }
+}

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

@@ -9,4 +9,6 @@ export declare class RuntimePaths {
     runnerConfigPath(): string;
     runnerStateDbPath(): string;
     runnerLogPath(): string;
+    serviceRuntimePath(): string;
+    serviceLogPath(service: "api" | "frontend"): string;
 }

package/dist/core/runtime/RuntimePaths.js

@@ -5,7 +5,7 @@ export class RuntimePaths {
         this.root = root;
     }
     stateFilePath() {
-        return path.join(this.root, "state.json");
+        return path.join(this.root, "state.yaml");
     }
     composeFilePath() {
         return path.join(this.root, "docker-compose.yaml");
@@ -28,4 +28,10 @@ export class RuntimePaths {
     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

@@ -4,6 +4,16 @@ export interface RuntimePorts {
     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: {
@@ -11,7 +21,7 @@ export interface RuntimeState {
         name: string;
     };
     auth: {
-        username: "admin";
+        username: string;
         password: string;
         jwtPrivateKeyPem: string;
         jwtPublicKeyPem: string;
@@ -21,4 +31,8 @@ export interface RuntimeState {
         secret: string;
     };
     ports: RuntimePorts;
+    services: {
+        api: ManagedServiceRuntime;
+        frontend: ManagedServiceRuntime;
+    };
 }

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

@@ -2,8 +2,10 @@ 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,10 +1,12 @@
 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);
@@ -23,7 +25,7 @@ export class RuntimeStateStore {
                 name: "Local CompanyHelm"
             },
             auth: {
-                username: "admin",
+                username: RuntimeStateStore.DEFAULT_USERNAME,
                 password: randomSecret(),
                 jwtPrivateKeyPem: authKeys.privateKeyPem,
                 jwtPublicKeyPem: authKeys.publicKeyPem
@@ -32,7 +34,15 @@ export class RuntimeStateStore {
                 name: "local-runner",
                 secret: randomSecret()
             },
-            ports: new PortAllocator().allocate()
+            ports: new PortAllocator().allocate(),
+            services: {
+                api: {
+                    source: "docker"
+                },
+                frontend: {
+                    source: "docker"
+                }
+            }
         };
         this.save(state);
         return state;
@@ -41,10 +51,29 @@ export class RuntimeStateStore {
         if (!fs.existsSync(this.runtimePaths.stateFilePath())) {
             return null;
         }
-        return JSON.parse(fs.readFileSync(this.runtimePaths.stateFilePath(), "utf8"));
+        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(), `${JSON.stringify(state, null, 2)}\n`, {
+        fs.writeFileSync(this.runtimePaths.stateFilePath(), YAML.stringify(state), {
             encoding: "utf8",
             mode: 0o600
         });

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

@@ -0,0 +1,10 @@
+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

@@ -0,0 +1,21 @@
+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/status/StatusService.d.ts

@@ -5,8 +5,15 @@ export interface StatusSnapshot {
     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;
-    constructor(listRunningServices: () => Promise<string>);
+    private readonly overrides;
+    constructor(listRunningServices: () => Promise<string>, overrides?: StatusOverrides);
     read(): Promise<StatusSnapshot>;
+    private resolveServiceRunning;
 }

package/dist/core/status/StatusService.js

@@ -1,18 +1,30 @@
 export class StatusService {
     listRunningServices;
-    constructor(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: running.has("api") ? "running" : "stopped",
-            frontend: running.has("frontend") ? "running" : "stopped",
-            runner: running.has("runner") ? "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,7 +1,17 @@
+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;
 }