@companyhelm/cli 0.4.1 → 0.4.2

package/dist/core/local/WebLocalService.js

@@ -1,101 +0,0 @@
-import fs from "node:fs";
-import net from "node:net";
-import { LocalServiceProcessManager } from "./LocalServiceProcessManager.js";
-import { CommandRunner } from "../process/CommandRunner.js";
-export class WebLocalService {
-    processManager;
-    commandRunner;
-    static SERVICE_NAME = "companyhelm-web";
-    constructor(processManager = new LocalServiceProcessManager(), commandRunner = new CommandRunner()) {
-        this.processManager = processManager;
-        this.commandRunner = commandRunner;
-    }
-    async start(input) {
-        await this.assertUiPortAvailable(input.uiPort);
-        await this.ensureNodeModules(input.repoPath);
-        await this.commandRunner.run("npm", ["run", "config:generate", "--", "--config-path", input.configPath], input.repoPath, {
-            APP_ENV: "local"
-        });
-        const runtime = this.processManager.start({
-            serviceName: WebLocalService.SERVICE_NAME,
-            repoPath: input.repoPath,
-            command: process.execPath,
-            args: [
-                "./node_modules/vite/bin/vite.js",
-                "dev",
-                "--host",
-                "0.0.0.0",
-                "--port",
-                String(input.uiPort)
-            ],
-            logPath: input.logPath,
-            env: {
-                APP_ENV: "local",
-                COMPANYHELM_LOG_LEVEL: input.logLevel,
-                npm_config_loglevel: input.logLevel
-            }
-        });
-        await this.waitForReadiness(input.url, runtime);
-        return runtime;
-    }
-    async ensureNodeModules(repoPath) {
-        if (fs.existsSync(`${repoPath}/node_modules`)) {
-            return;
-        }
-        await this.commandRunner.run("npm", ["install"], repoPath);
-    }
-    async waitForReadiness(url, runtime) {
-        const deadline = Date.now() + 60_000;
-        while (Date.now() < deadline) {
-            if (!this.processManager.isRunning(runtime)) {
-                throw new Error(this.buildStartupFailureMessage(runtime, `${WebLocalService.SERVICE_NAME} exited before becoming ready.`));
-            }
-            try {
-                const response = await fetch(url);
-                if (response.ok) {
-                    return;
-                }
-            }
-            catch {
-                // Retry until the deadline.
-            }
-            await new Promise((resolve) => {
-                setTimeout(resolve, 1000);
-            });
-        }
-        throw new Error(`companyhelm-web did not become ready: ${url}`);
-    }
-    async assertUiPortAvailable(port) {
-        await new Promise((resolve, reject) => {
-            const server = net.createServer();
-            server.once("error", (error) => {
-                if (error.code === "EADDRINUSE") {
-                    reject(new Error(`companyhelm-web cannot start because port ${port} is already in use.`));
-                    return;
-                }
-                reject(new Error(`companyhelm-web cannot verify port ${port}: ${error.message}`));
-            });
-            server.once("listening", () => {
-                server.close((closeError) => {
-                    if (closeError) {
-                        reject(closeError);
-                        return;
-                    }
-                    resolve();
-                });
-            });
-            server.listen(port, "0.0.0.0");
-        });
-    }
-    buildStartupFailureMessage(runtime, summary) {
-        if (!fs.existsSync(runtime.logPath)) {
-            return summary;
-        }
-        const startupLog = fs.readFileSync(runtime.logPath, "utf8").trim();
-        if (!startupLog) {
-            return summary;
-        }
-        const tail = startupLog.split(/\r?\n/).slice(-20).join("\n");
-        return `${summary}\nStartup log:\n${tail}`;
-    }
-}

package/dist/core/logs/LogsService.d.ts

@@ -1,6 +0,0 @@
-import { type ManagedServiceKey } from "../services/ManagedServiceNames.js";
-export declare class LogsService {
-    private readonly streamServiceLogs;
-    constructor(streamServiceLogs: (service: ManagedServiceKey) => Promise<void>);
-    stream(service: string): Promise<void>;
-}

package/dist/core/logs/LogsService.js

@@ -1,14 +0,0 @@
-import { AVAILABLE_MANAGED_SERVICE_NAMES, resolveManagedServiceKey } from "../services/ManagedServiceNames.js";
-export class LogsService {
-    streamServiceLogs;
-    constructor(streamServiceLogs) {
-        this.streamServiceLogs = streamServiceLogs;
-    }
-    async stream(service) {
-        const resolvedService = resolveManagedServiceKey(service);
-        if (!resolvedService) {
-            throw new Error(`Unknown service '${service}'. Expected one of: ${AVAILABLE_MANAGED_SERVICE_NAMES.join(", ")}`);
-        }
-        await this.streamServiceLogs(resolvedService);
-    }
-}

package/dist/core/process/CommandRunner.d.ts

@@ -1,4 +0,0 @@
-export declare class CommandRunner {
-    run(command: string, args: string[], cwd?: string, env?: NodeJS.ProcessEnv): Promise<void>;
-    capture(command: string, args: string[], cwd?: string, env?: NodeJS.ProcessEnv): Promise<string>;
-}

package/dist/core/process/CommandRunner.js

@@ -1,51 +0,0 @@
-import { spawn } from "node:child_process";
-export class CommandRunner {
-    run(command, args, cwd, env) {
-        return new Promise((resolve, reject) => {
-            const child = spawn(command, args, {
-                cwd,
-                env: {
-                    ...process.env,
-                    ...env
-                },
-                stdio: "inherit"
-            });
-            child.on("error", reject);
-            child.on("exit", (code) => {
-                if (code === 0) {
-                    resolve();
-                    return;
-                }
-                reject(new Error(`${command} exited with code ${code ?? "unknown"}`));
-            });
-        });
-    }
-    capture(command, args, cwd, env) {
-        return new Promise((resolve, reject) => {
-            const child = spawn(command, args, {
-                cwd,
-                env: {
-                    ...process.env,
-                    ...env
-                },
-                stdio: ["ignore", "pipe", "pipe"]
-            });
-            let stdout = "";
-            let stderr = "";
-            child.stdout.on("data", (chunk) => {
-                stdout += String(chunk);
-            });
-            child.stderr.on("data", (chunk) => {
-                stderr += String(chunk);
-            });
-            child.on("error", reject);
-            child.on("exit", (code) => {
-                if (code === 0) {
-                    resolve(stdout);
-                    return;
-                }
-                reject(new Error(stderr || `${command} exited with code ${code ?? "unknown"}`));
-            });
-        });
-    }
-}

package/dist/core/runner/RunnerSupervisor.d.ts

@@ -1,29 +0,0 @@
-import type { LogLevel } from "../../commands/dependencies.js";
-import type { AgentWorkspaceMode } from "../runtime/LocalConfigStore.js";
-export interface RunnerStartInput {
-    serverUrl: string;
-    agentApiUrl: string;
-    logPath: string;
-    secret: string;
-    logLevel?: LogLevel;
-    useHostDockerRuntime?: boolean;
-    workspaceMode?: AgentWorkspaceMode;
-    projectRoot?: string;
-}
-export interface RunnerStartCommand {
-    command: string;
-    args: string[];
-    env?: NodeJS.ProcessEnv;
-}
-export declare class RunnerSupervisor {
-    private readonly configPath;
-    constructor(configPath: string);
-    buildUseHostAuthArgs(): RunnerStartCommand;
-    buildStartArgs(input: RunnerStartInput): RunnerStartCommand;
-    buildStopArgs(): RunnerStartCommand;
-    buildStatusArgs(): RunnerStartCommand;
-    private resolveRunnerCliPath;
-    private resolveRunnerCliOverridePath;
-    private resolveRunnerEntrypointPath;
-    private resolveHostDockerPath;
-}

package/dist/core/runner/RunnerSupervisor.js

@@ -1,90 +0,0 @@
-import path from "node:path";
-import { createRequire } from "node:module";
-import { fileURLToPath } from "node:url";
-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 logLevel = (input.logLevel ?? "info").toUpperCase();
-        const hostDockerArgs = input.useHostDockerRuntime
-            ? ["--use-host-docker-runtime", "--host-docker-path", this.resolveHostDockerPath()]
-            : [];
-        const runnerEntrypoint = this.resolveRunnerEntrypointPath();
-        const runnerCliOverridePath = this.resolveRunnerCliOverridePath();
-        const env = input.workspaceMode === "current-working-directory" && input.projectRoot
-            ? {
-                COMPANYHELM_RUNNER_WORKSPACE_MODE: input.workspaceMode,
-                COMPANYHELM_RUNNER_PROJECT_ROOT: input.projectRoot,
-            }
-            : undefined;
-        return {
-            command: process.execPath,
-            args: [
-                runnerEntrypoint,
-                ...(runnerCliOverridePath ? [runnerCliOverridePath] : []),
-                "--config-path",
-                this.configPath,
-                "start",
-                "--daemon",
-                "--server-url",
-                input.serverUrl,
-                "--agent-api-url",
-                input.agentApiUrl,
-                "--log-path",
-                input.logPath,
-                ...hostDockerArgs,
-                "--secret",
-                input.secret,
-                "--log-level",
-                logLevel
-            ],
-            env
-        };
-    }
-    buildStopArgs() {
-        const runnerCliPath = this.resolveRunnerCliPath();
-        return {
-            command: process.execPath,
-            args: [runnerCliPath, "--config-path", this.configPath, "stop"]
-        };
-    }
-    buildStatusArgs() {
-        const runnerCliPath = this.resolveRunnerCliPath();
-        return {
-            command: process.execPath,
-            args: [runnerCliPath, "--config-path", this.configPath, "status"]
-        };
-    }
-    resolveRunnerCliPath() {
-        if (process.env.COMPANYHELM_RUNNER_CLI_PATH) {
-            return process.env.COMPANYHELM_RUNNER_CLI_PATH;
-        }
-        const packageJsonPath = require.resolve("@companyhelm/runner/package.json");
-        return path.resolve(path.dirname(packageJsonPath), "dist/cli.js");
-    }
-    resolveRunnerCliOverridePath() {
-        const overridePath = String(process.env.COMPANYHELM_RUNNER_CLI_PATH || "").trim();
-        return overridePath || null;
-    }
-    resolveRunnerEntrypointPath() {
-        return path.resolve(path.dirname(fileURLToPath(import.meta.url)), "runner-bootstrap.js");
-    }
-    resolveHostDockerPath() {
-        const dockerHost = String(process.env.DOCKER_HOST || "").trim();
-        if (dockerHost) {
-            return dockerHost;
-        }
-        return DEFAULT_HOST_DOCKER_PATH;
-    }
-}

package/dist/core/runner/runner-bootstrap.d.ts

@@ -1,2 +0,0 @@
-export declare function resolveRunnerCliEntrypointArg(argv: string[]): string | null;
-export declare function runRunnerBootstrap(): Promise<void>;

package/dist/core/runner/runner-bootstrap.js

@@ -1,48 +0,0 @@
-import path from "node:path";
-import { createRequire } from "node:module";
-import { pathToFileURL } from "node:url";
-const require = createRequire(import.meta.url);
-function applyCurrentWorkingDirectoryMode(projectRoot) {
-    const resolvedProjectRoot = path.resolve(projectRoot);
-    const fsModule = require("node:fs");
-    const originalRmSync = fsModule.rmSync.bind(fsModule);
-    fsModule.rmSync = ((target, options) => {
-        if (path.resolve(String(target)) === resolvedProjectRoot) {
-            return;
-        }
-        return originalRmSync(target, options);
-    });
-    const configModule = require("@companyhelm/runner/dist/config.js");
-    const originalParse = configModule.config.parse.bind(configModule.config);
-    configModule.config.parse = ((input = {}) => originalParse({
-        ...input,
-        workspaces_directory: resolvedProjectRoot
-    }));
-    const threadLifecycle = require("@companyhelm/runner/dist/service/thread_lifecycle.js");
-    threadLifecycle.resolveThreadDirectory = (() => resolvedProjectRoot);
-}
-export function resolveRunnerCliEntrypointArg(argv) {
-    const candidate = String(argv[2] || "").trim();
-    if (!candidate || candidate.startsWith("-")) {
-        return null;
-    }
-    return candidate;
-}
-const workspaceMode = String(process.env.COMPANYHELM_RUNNER_WORKSPACE_MODE || "").trim();
-const projectRoot = String(process.env.COMPANYHELM_RUNNER_PROJECT_ROOT || "").trim();
-export async function runRunnerBootstrap() {
-    if (workspaceMode === "current-working-directory" && projectRoot) {
-        applyCurrentWorkingDirectoryMode(projectRoot);
-    }
-    const runnerEntrypoint = resolveRunnerCliEntrypointArg(process.argv);
-    if (runnerEntrypoint) {
-        process.argv.splice(2, 1);
-    }
-    await import(runnerEntrypoint ? pathToFileURL(runnerEntrypoint).href : "@companyhelm/runner/dist/cli.js");
-}
-const invokedAsEntrypoint = process.argv[1]
-    ? pathToFileURL(path.resolve(process.argv[1])).href === import.meta.url
-    : false;
-if (invokedAsEntrypoint) {
-    await runRunnerBootstrap();
-}

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

@@ -1,3 +0,0 @@
-export declare class CliPackageMetadata {
-    version(): string;
-}

package/dist/core/runtime/CliPackageMetadata.js

@@ -1,8 +0,0 @@
-import { readFileSync } from "node:fs";
-export class CliPackageMetadata {
-    version() {
-        const manifestPath = new URL("../../../package.json", import.meta.url);
-        const manifest = JSON.parse(readFileSync(manifestPath, "utf8"));
-        return manifest.version;
-    }
-}

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

@@ -1,2 +0,0 @@
-export declare function defaultCliRoot(): string;
-export declare function defaultCliConfigRoot(): string;

package/dist/core/runtime/CliRoot.js

@@ -1,23 +0,0 @@
-import os from "node:os";
-import path from "node:path";
-function defaultCliBaseRoot() {
-    return path.join(os.homedir(), ".companyhelm", "cli");
-}
-export function defaultCliRoot() {
-    const explicitRoot = String(process.env.COMPANYHELM_HOME || "").trim();
-    if (explicitRoot) {
-        return path.resolve(explicitRoot);
-    }
-    return path.join(defaultCliBaseRoot(), "runtime");
-}
-export function defaultCliConfigRoot() {
-    const explicitRoot = String(process.env.COMPANYHELM_CONFIG_HOME || "").trim();
-    if (explicitRoot) {
-        return path.resolve(explicitRoot);
-    }
-    const explicitRuntimeRoot = String(process.env.COMPANYHELM_HOME || "").trim();
-    if (explicitRuntimeRoot) {
-        return path.resolve(explicitRuntimeRoot);
-    }
-    return defaultCliBaseRoot();
-}

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

@@ -1,11 +0,0 @@
-import { ImageConfigStore } from "./ImageConfigStore.js";
-export interface RuntimeImages {
-    api: string;
-    frontend: string;
-    postgres: string;
-}
-export declare class ImageCatalog {
-    private readonly configStore;
-    constructor(configStore?: ImageConfigStore);
-    resolve(): RuntimeImages;
-}

package/dist/core/runtime/ImageCatalog.js

@@ -1,16 +0,0 @@
-import { defaultManagedImageReference } from "./ManagedImages.js";
-import { ImageConfigStore } from "./ImageConfigStore.js";
-export class ImageCatalog {
-    configStore;
-    constructor(configStore = new ImageConfigStore()) {
-        this.configStore = configStore;
-    }
-    resolve() {
-        const configuredImages = this.configStore.load().images;
-        return {
-            api: process.env.COMPANYHELM_API_IMAGE || configuredImages.api || defaultManagedImageReference("api"),
-            frontend: process.env.COMPANYHELM_WEB_IMAGE || configuredImages.frontend || defaultManagedImageReference("frontend"),
-            postgres: process.env.COMPANYHELM_POSTGRES_IMAGE || "postgres:16-alpine"
-        };
-    }
-}

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

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

package/dist/core/runtime/ImageConfigStore.js

@@ -1,51 +0,0 @@
-import fs from "node:fs";
-import path from "node:path";
-import { fileURLToPath } from "node:url";
-import { MANAGED_IMAGE_SERVICES, defaultManagedImageReference } from "./ManagedImages.js";
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = path.dirname(__filename);
-function defaultPackageRoot() {
-    return path.resolve(__dirname, "../../..");
-}
-export class ImageConfigStore {
-    root;
-    constructor(root = defaultPackageRoot()) {
-        this.root = root;
-    }
-    configPath() {
-        return path.join(this.root, "src", "config", "image_config.ts");
-    }
-    load() {
-        const configPath = this.configPath();
-        if (!fs.existsSync(configPath)) {
-            return { images: {} };
-        }
-        const images = {};
-        for (const rawLine of fs.readFileSync(configPath, "utf8").split(/\r?\n/)) {
-            const match = rawLine.match(/^\s+(api|frontend):\s+"([^"]+)",?$/);
-            if (match) {
-                images[match[1]] = match[2];
-            }
-        }
-        return { images };
-    }
-    setImage(service, image) {
-        const nextConfig = this.load();
-        nextConfig.images[service] = image;
-        this.save(nextConfig);
-        return { configPath: this.configPath(), image };
-    }
-    save(config) {
-        const lines = [
-            "export const PACKAGED_IMAGE_CONFIG = {",
-            ...MANAGED_IMAGE_SERVICES.map((service) => {
-                const image = config.images[service] ?? defaultManagedImageReference(service);
-                return `  ${service}: "${image}"`;
-            }).map((line, index, all) => `${line}${index < all.length - 1 ? "," : ""}`),
-            "} as const;",
-            ""
-        ];
-        fs.mkdirSync(path.dirname(this.configPath()), { recursive: true });
-        fs.writeFileSync(this.configPath(), lines.join("\n"), "utf8");
-    }
-}

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

@@ -1,16 +0,0 @@
-export type AgentWorkspaceMode = "dedicated" | "current-working-directory";
-export interface LocalConfig {
-    agentWorkspaceMode?: AgentWorkspaceMode;
-}
-export declare class LocalConfigStore {
-    private readonly root;
-    constructor(root?: string);
-    configPath(): string;
-    load(): LocalConfig;
-    setAgentWorkspaceMode(agentWorkspaceMode: AgentWorkspaceMode): {
-        configPath: string;
-        agentWorkspaceMode: AgentWorkspaceMode;
-    };
-    save(config: LocalConfig): void;
-    private parse;
-}

package/dist/core/runtime/LocalConfigStore.js

@@ -1,50 +0,0 @@
-import fs from "node:fs";
-import path from "node:path";
-import { defaultCliConfigRoot } from "./CliRoot.js";
-function defaultLocalConfigRoot() {
-    return defaultCliConfigRoot();
-}
-export class LocalConfigStore {
-    root;
-    constructor(root = defaultLocalConfigRoot()) {
-        this.root = root;
-    }
-    configPath() {
-        return path.join(this.root, "config.yaml");
-    }
-    load() {
-        const configPath = this.configPath();
-        if (!fs.existsSync(configPath)) {
-            return {};
-        }
-        return this.parse(fs.readFileSync(configPath, "utf8"));
-    }
-    setAgentWorkspaceMode(agentWorkspaceMode) {
-        const nextConfig = this.load();
-        nextConfig.agentWorkspaceMode = agentWorkspaceMode;
-        this.save(nextConfig);
-        return { configPath: this.configPath(), agentWorkspaceMode };
-    }
-    save(config) {
-        const lines = [];
-        if (config.agentWorkspaceMode) {
-            lines.push(`agent_workspace_mode: ${config.agentWorkspaceMode}`);
-        }
-        fs.mkdirSync(path.dirname(this.configPath()), { recursive: true });
-        fs.writeFileSync(this.configPath(), `${lines.join("\n")}\n`, "utf8");
-    }
-    parse(content) {
-        let agentWorkspaceMode;
-        for (const rawLine of content.split(/\r?\n/)) {
-            const line = rawLine.trimEnd();
-            if (line.trim().length === 0 || line.trimStart().startsWith("#")) {
-                continue;
-            }
-            const workspaceModeMatch = line.match(/^agent_workspace_mode:\s*(dedicated|current-working-directory)$/);
-            if (workspaceModeMatch) {
-                agentWorkspaceMode = workspaceModeMatch[1];
-            }
-        }
-        return { agentWorkspaceMode };
-    }
-}

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

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

@@ -1,27 +0,0 @@
-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/PortAllocator.d.ts

@@ -1,9 +0,0 @@
-import type { RuntimePorts } from "./RuntimeState.js";
-export declare class PortAllocator {
-    private readonly apiHttpPort;
-    private readonly uiPort;
-    private readonly runnerGrpcPort;
-    private readonly agentCliGrpcPort;
-    constructor(apiHttpPort?: number, uiPort?: number, runnerGrpcPort?: number, agentCliGrpcPort?: number);
-    allocate(): RuntimePorts;
-}

package/dist/core/runtime/PortAllocator.js

@@ -1,20 +0,0 @@
-export class PortAllocator {
-    apiHttpPort;
-    uiPort;
-    runnerGrpcPort;
-    agentCliGrpcPort;
-    constructor(apiHttpPort = 4000, uiPort = 4173, runnerGrpcPort = 50051, agentCliGrpcPort = 50052) {
-        this.apiHttpPort = apiHttpPort;
-        this.uiPort = uiPort;
-        this.runnerGrpcPort = runnerGrpcPort;
-        this.agentCliGrpcPort = agentCliGrpcPort;
-    }
-    allocate() {
-        return {
-            apiHttp: this.apiHttpPort,
-            ui: this.uiPort,
-            runnerGrpc: this.runnerGrpcPort,
-            agentCliGrpc: this.agentCliGrpcPort
-        };
-    }
-}

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

@@ -1,17 +0,0 @@
-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;
-    private mapWithConcurrency;
-}
-export {};