@companyhelm/cli 0.4.1 → 0.4.2

package/dist/commands/dependencies.js

@@ -1,292 +0,0 @@
-import fs from "node:fs";
-import { DeploymentBootstrapper } from "../core/bootstrap/DeploymentBootstrapper.js";
-import { ApiEnvFileWriter } from "../core/config/ApiEnvFileWriter.js";
-import { GithubAppConfigStore } from "../core/config/GithubAppConfigStore.js";
-import { DockerStackManager } from "../core/docker/DockerStackManager.js";
-import { ApiLocalService } from "../core/local/ApiLocalService.js";
-import { LocalRepoSourceResolver } from "../core/local/LocalRepoSourceResolver.js";
-import { LocalServiceProcessManager } from "../core/local/LocalServiceProcessManager.js";
-import { WebLocalService } from "../core/local/WebLocalService.js";
-import { LogsService } from "../core/logs/LogsService.js";
-import { CommandRunner } from "../core/process/CommandRunner.js";
-import { RunnerSupervisor } from "../core/runner/RunnerSupervisor.js";
-import { defaultCliRoot } from "../core/runtime/CliRoot.js";
-import { createPasswordHash } from "../core/runtime/Secrets.js";
-import { RuntimePaths } from "../core/runtime/RuntimePaths.js";
-import { RuntimeStateStore } from "../core/runtime/RuntimeStateStore.js";
-import { VersionCatalog } from "../core/runtime/VersionCatalog.js";
-import { StatusService } from "../core/status/StatusService.js";
-import { TerminalRenderer } from "../core/ui/TerminalRenderer.js";
-import { LocalConfigStore } from "../core/runtime/LocalConfigStore.js";
-import { PortAllocator } from "../core/runtime/PortAllocator.js";
-import { runStartupPreflightChecks } from "../preflight/runStartupPreflightChecks.js";
-import { ensureGithubAppConfig } from "./setup-github-app.js";
-import { ensureAgentWorkspaceMode } from "./startup-preferences.js";
-function runtimeRoot() {
-    return defaultCliRoot();
-}
-export function createDefaultDependencies() {
-    const root = runtimeRoot();
-    const stateStore = new RuntimeStateStore(root);
-    const runtimePaths = new RuntimePaths(root);
-    const commandRunner = new CommandRunner();
-    const renderer = new TerminalRenderer(process.stdout.isTTY);
-    const dockerStackManager = new DockerStackManager(root, commandRunner);
-    const runnerSupervisor = new RunnerSupervisor(runtimePaths.runnerConfigPath());
-    const bootstrapper = new DeploymentBootstrapper();
-    const githubAppConfigStore = new GithubAppConfigStore();
-    const apiEnvFileWriter = new ApiEnvFileWriter(root);
-    const localRepoSourceResolver = new LocalRepoSourceResolver(process.cwd());
-    const localConfigStore = new LocalConfigStore();
-    const localServiceProcessManager = new LocalServiceProcessManager();
-    const apiLocalService = new ApiLocalService(localServiceProcessManager, commandRunner);
-    const webLocalService = new WebLocalService(localServiceProcessManager, commandRunner);
-    const versionCatalog = new VersionCatalog();
-    const statusService = new StatusService(() => dockerStackManager.runningServices(), {
-        api: () => {
-            const state = stateStore.load();
-            return state?.services.api.source === "local"
-                ? localServiceProcessManager.isRunning(state.services.api)
-                : undefined;
-        },
-        frontend: () => {
-            const state = stateStore.load();
-            return state?.services.frontend.source === "local"
-                ? localServiceProcessManager.isRunning(state.services.frontend)
-                : undefined;
-        },
-        runner: async () => {
-            try {
-                const statusCommand = runnerSupervisor.buildStatusArgs();
-                const output = await commandRunner.capture(statusCommand.command, statusCommand.args);
-                return output.includes("Daemon: running");
-            }
-            catch {
-                return false;
-            }
-        }
-    });
-    const logsService = new LogsService(async (service) => {
-        if (service === "runner") {
-            if (fs.existsSync(runtimePaths.runnerLogPath())) {
-                process.stdout.write(fs.readFileSync(runtimePaths.runnerLogPath(), "utf8"));
-            }
-            return;
-        }
-        const state = stateStore.load();
-        if (service === "api" && state?.services.api.source === "local") {
-            localServiceProcessManager.printLogs(state.services.api);
-            return;
-        }
-        if (service === "frontend" && state?.services.frontend.source === "local") {
-            localServiceProcessManager.printLogs(state.services.frontend);
-            return;
-        }
-        await dockerStackManager.logs(service);
-    });
-    return {
-        async up(options = {}) {
-            const logLevel = options.logLevel ?? "info";
-            const useHostDockerRuntime = options.useHostDockerRuntime ?? false;
-            process.stdout.write(`${renderer.renderBanner()}\n`);
-            const desiredSources = localRepoSourceResolver.resolve(options);
-            const currentState = stateStore.load();
-            const allocatedPorts = currentState?.ports ?? new PortAllocator().allocate();
-            await runStartupPreflightChecks({
-                commandRunner,
-                currentState,
-                desiredSources,
-                ports: allocatedPorts,
-                readStatus: () => statusService.read()
-            });
-            const workspaceMode = await ensureAgentWorkspaceMode(localConfigStore, process.stdin, process.stdout);
-            const githubAppConfig = await ensureGithubAppConfig(githubAppConfigStore, process.stdin, process.stdout, { workspaceMode });
-            const state = currentState ?? stateStore.initialize();
-            const runnerAlreadyRunning = await isRunnerRunning(commandRunner, runnerSupervisor);
-            const versions = versionCatalog.resolve();
-            const passwordRecord = createPasswordHash(state.auth.password);
-            const startedLocalServices = [];
-            let runnerStarted = false;
-            fs.mkdirSync(root, { recursive: true });
-            fs.mkdirSync(runtimePaths.serviceRuntimePath(), { recursive: true });
-            apiEnvFileWriter.write(githubAppConfig);
-            bootstrapper.writeSeedSql(root, state, passwordRecord.passwordHash, passwordRecord.passwordSalt);
-            bootstrapper.writeApiConfig(root, state, logLevel, {
-                databaseHost: desiredSources.api.source === "local" ? "127.0.0.1" : "postgres",
-                githubAppConfig
-            });
-            bootstrapper.writeFrontendConfig(root, state);
-            await stopLocalServicesFromState(stateStore.load(), localServiceProcessManager);
-            try {
-                await dockerStackManager.up(state, {
-                    frontendLogLevel: logLevel,
-                    includeApi: desiredSources.api.source === "docker",
-                    includeFrontend: desiredSources.frontend.source === "docker",
-                    exposePostgresPort: desiredSources.api.source === "local"
-                });
-                const apiUrl = `http://127.0.0.1:${state.ports.apiHttp}/graphql`;
-                const uiUrl = `http://127.0.0.1:${state.ports.ui}`;
-                if (desiredSources.api.source === "local") {
-                    process.stdout.write(`${renderer.progress(`Starting companyhelm-api from ${desiredSources.api.repoPath}...`)}\n`);
-                    state.services.api = await apiLocalService.start({
-                        repoPath: desiredSources.api.repoPath,
-                        configPath: runtimePaths.apiConfigPath(),
-                        graphqlUrl: apiUrl,
-                        logPath: runtimePaths.serviceLogPath("api"),
-                        githubAppConfig,
-                        state,
-                        logLevel
-                    });
-                    startedLocalServices.push("api");
-                }
-                else {
-                    state.services.api = { source: "docker" };
-                }
-                process.stdout.write(`${renderer.progress("Initializing the database...")}\n`);
-                process.stdout.write(`${renderer.progress("Waiting for database migrations...")}\n`);
-                await dockerStackManager.applySeedSql(state.auth.username);
-                if (runnerAlreadyRunning) {
-                    process.stdout.write(`${renderer.progress("Runner already running; skipping startup.")}\n`);
-                }
-                else {
-                    const configureSdkCommand = runnerSupervisor.buildUseHostAuthArgs();
-                    process.stdout.write(`${renderer.progress("Configuring runner authentication...")}\n`);
-                    await commandRunner.run(configureSdkCommand.command, configureSdkCommand.args);
-                    const startCommand = runnerSupervisor.buildStartArgs({
-                        serverUrl: `127.0.0.1:${state.ports.runnerGrpc}`,
-                        agentApiUrl: `http://127.0.0.1:${state.ports.apiHttp}/agent/v1`,
-                        logPath: runtimePaths.runnerLogPath(),
-                        secret: state.runner.secret,
-                        logLevel,
-                        useHostDockerRuntime,
-                        workspaceMode,
-                        projectRoot: process.cwd()
-                    });
-                    process.stdout.write(`${renderer.progress("Starting the runner...")}\n`);
-                    await commandRunner.run(startCommand.command, startCommand.args, undefined, startCommand.env);
-                    runnerStarted = true;
-                }
-                if (desiredSources.frontend.source === "local") {
-                    process.stdout.write(`${renderer.progress(`Starting companyhelm-web from ${desiredSources.frontend.repoPath}...`)}\n`);
-                    state.services.frontend = await webLocalService.start({
-                        repoPath: desiredSources.frontend.repoPath,
-                        configPath: runtimePaths.frontendConfigPath(),
-                        url: uiUrl,
-                        uiPort: state.ports.ui,
-                        logPath: runtimePaths.serviceLogPath("frontend"),
-                        logLevel
-                    });
-                    startedLocalServices.push("frontend");
-                }
-                else {
-                    state.services.frontend = { source: "docker" };
-                }
-                stateStore.persist(state);
-                process.stdout.write(`${renderer.success(`API ready: ${apiUrl}`)}\n`);
-                process.stdout.write(`CompanyHelm CLI: ${versions.cliPackage}\n`);
-                process.stdout.write(`Runner package: ${versions.runnerPackage}\n`);
-                process.stdout.write(desiredSources.api.source === "local"
-                    ? `API repo: ${desiredSources.api.repoPath}\n`
-                    : `API image: ${versions.images.api}\n`);
-                process.stdout.write(desiredSources.frontend.source === "local"
-                    ? `companyhelm-web repo: ${desiredSources.frontend.repoPath}\n`
-                    : `companyhelm-web image: ${versions.images.frontend}\n`);
-                process.stdout.write(`Postgres image: ${versions.images.postgres}\n`);
-                process.stdout.write(`\n${renderer.success("CompanyHelm started successfully.")}\n`);
-                process.stdout.write(`${renderer.successHighlight("UI URL")}\n`);
-                process.stdout.write(`${renderer.clickableUrl(uiUrl)}\n`);
-                process.stdout.write(`${renderer.successHighlight("Login credentials")}\n`);
-                process.stdout.write(`username: ${state.auth.username}\n`);
-                process.stdout.write(`password: ${state.auth.password}\n`);
-            }
-            catch (error) {
-                if (runnerStarted) {
-                    const stopCommand = runnerSupervisor.buildStopArgs();
-                    try {
-                        await commandRunner.run(stopCommand.command, stopCommand.args);
-                    }
-                    catch {
-                        // Ignore runner stop failures during cleanup.
-                    }
-                }
-                for (const service of startedLocalServices.reverse()) {
-                    const runtime = service === "api" ? state.services.api : state.services.frontend;
-                    if (runtime.source === "local") {
-                        await localServiceProcessManager.stop(runtime);
-                    }
-                }
-                await dockerStackManager.down();
-                throw error;
-            }
-        },
-        async down() {
-            const stopCommand = runnerSupervisor.buildStopArgs();
-            try {
-                await commandRunner.run(stopCommand.command, stopCommand.args);
-            }
-            catch {
-                // Ignore runner stop failures during teardown so container cleanup still happens.
-            }
-            const state = stateStore.load();
-            if (!state) {
-                return;
-            }
-            await stopLocalServicesFromState(state, localServiceProcessManager);
-            await dockerStackManager.down();
-        },
-        async status() {
-            const services = await statusService.read();
-            const state = stateStore.load();
-            return {
-                services,
-                apiUrl: state ? `http://127.0.0.1:${state.ports.apiHttp}/graphql` : undefined,
-                uiUrl: state ? `http://127.0.0.1:${state.ports.ui}` : undefined,
-                username: state?.auth.username,
-                versions: versionCatalog.resolve()
-            };
-        },
-        logs(service) {
-            return logsService.stream(service);
-        },
-        async reset(options = {}) {
-            const state = stateStore.load();
-            if (state) {
-                const stopCommand = runnerSupervisor.buildStopArgs();
-                try {
-                    await commandRunner.run(stopCommand.command, stopCommand.args);
-                }
-                catch {
-                    // Ignore runner stop failures during teardown so docker cleanup still runs.
-                }
-                await stopLocalServicesFromState(state, localServiceProcessManager);
-            }
-            await dockerStackManager.down({ removeVolumes: true });
-            fs.rmSync(localConfigStore.configPath(), { force: true });
-            fs.rmSync(root, { recursive: true, force: true });
-            if (options.removeGithubAppConfig) {
-                githubAppConfigStore.delete();
-            }
-        }
-    };
-}
-async function stopLocalServicesFromState(state, processManager) {
-    if (!state) {
-        return;
-    }
-    if (state.services.api.source === "local") {
-        await processManager.stop(state.services.api);
-    }
-    if (state.services.frontend.source === "local") {
-        await processManager.stop(state.services.frontend);
-    }
-}
-async function isRunnerRunning(commandRunner, runnerSupervisor) {
-    try {
-        const statusCommand = runnerSupervisor.buildStatusArgs();
-        const output = await commandRunner.capture(statusCommand.command, statusCommand.args);
-        return output.includes("Daemon: running");
-    }
-    catch (error) {
-        return false;
-    }
-}

package/dist/commands/down.d.ts

@@ -1,3 +0,0 @@
-import type { Command } from "commander";
-import type { CommandDependencies } from "./dependencies.js";
-export declare function registerDownCommand(program: Command, dependencies: CommandDependencies): void;

package/dist/commands/down.js

@@ -1,5 +0,0 @@
-export function registerDownCommand(program, dependencies) {
-    program.command("down").description("Stop the local deployment.").action(async () => {
-        await dependencies.down();
-    });
-}

package/dist/commands/interactive.d.ts

@@ -1,7 +0,0 @@
-import type { Readable, Writable } from "node:stream";
-export declare class InteractiveCommandCancelledError extends Error {
-    constructor(message: string);
-}
-export declare function hasInteractiveTerminal(input: Readable, output: Writable): boolean;
-export declare function requireInteractiveTerminal(input: Readable, output: Writable, message: string): void;
-export declare function unwrapPromptResult<T>(value: T | symbol, message: string, output: Writable): T;

package/dist/commands/interactive.js

@@ -1,25 +0,0 @@
-import * as clack from "@clack/prompts";
-export class InteractiveCommandCancelledError extends Error {
-    constructor(message) {
-        super(message);
-        this.name = "InteractiveCommandCancelledError";
-    }
-}
-function isReadableTty(input) {
-    return "isTTY" in input && Boolean(input.isTTY);
-}
-export function hasInteractiveTerminal(input, output) {
-    return isReadableTty(input) && clack.isTTY(output);
-}
-export function requireInteractiveTerminal(input, output, message) {
-    if (!hasInteractiveTerminal(input, output)) {
-        throw new Error(message);
-    }
-}
-export function unwrapPromptResult(value, message, output) {
-    if (clack.isCancel(value)) {
-        clack.cancel(message, { output });
-        throw new InteractiveCommandCancelledError(message);
-    }
-    return value;
-}

package/dist/commands/logs.d.ts

@@ -1,3 +0,0 @@
-import type { Command } from "commander";
-import type { CommandDependencies } from "./dependencies.js";
-export declare function registerLogsCommand(program: Command, dependencies: CommandDependencies): void;

package/dist/commands/logs.js

@@ -1,14 +0,0 @@
-import { AVAILABLE_MANAGED_SERVICE_NAMES } from "../core/services/ManagedServiceNames.js";
-export function registerLogsCommand(program, dependencies) {
-    program
-        .command("logs")
-        .description("Show logs for a managed service.")
-        .argument("[service]")
-        .action(async (service) => {
-        if (!service) {
-            process.stdout.write(`Available services:\n${AVAILABLE_MANAGED_SERVICE_NAMES.map((name) => `- ${name}`).join("\n")}\n`);
-            return;
-        }
-        await dependencies.logs(service);
-    });
-}

package/dist/commands/register-commands.d.ts

@@ -1,3 +0,0 @@
-import { Command } from "commander";
-import { type CommandDependencies } from "./dependencies.js";
-export declare function buildProgram(dependencies?: CommandDependencies): Command;

package/dist/commands/register-commands.js

@@ -1,23 +0,0 @@
-import { Command } from "commander";
-import { createDefaultDependencies } from "./dependencies.js";
-import { CliPackageMetadata } from "../core/runtime/CliPackageMetadata.js";
-import { registerDownCommand } from "./down.js";
-import { registerLogsCommand } from "./logs.js";
-import { registerResetCommand } from "./reset.js";
-import { registerSetupGithubAppCommand } from "./setup-github-app.js";
-import { registerSetImageVersionCommand } from "./set-image-version.js";
-import { registerStatusCommand } from "./status.js";
-import { registerUpCommand } from "./up.js";
-export function buildProgram(dependencies = createDefaultDependencies()) {
-    const program = new Command()
-        .name("companyhelm")
-        .version(new CliPackageMetadata().version());
-    registerSetupGithubAppCommand(program);
-    registerUpCommand(program, dependencies);
-    registerDownCommand(program, dependencies);
-    registerStatusCommand(program, dependencies);
-    registerLogsCommand(program, dependencies);
-    registerSetImageVersionCommand(program);
-    registerResetCommand(program, dependencies);
-    return program;
-}

package/dist/commands/reset.d.ts

@@ -1,7 +0,0 @@
-import type { Readable, Writable } from "node:stream";
-import type { Command } from "commander";
-import { GithubAppConfigStore } from "../core/config/GithubAppConfigStore.js";
-import type { CommandDependencies } from "./dependencies.js";
-export declare function confirmReset(input?: Readable, output?: Writable): Promise<boolean>;
-export declare function confirmRemoveGithubAppConfig(store?: GithubAppConfigStore, input?: Readable, output?: Writable): Promise<boolean>;
-export declare function registerResetCommand(program: Command, dependencies: CommandDependencies): void;

package/dist/commands/reset.js

@@ -1,51 +0,0 @@
-import * as clack from "@clack/prompts";
-import { GithubAppConfigStore } from "../core/config/GithubAppConfigStore.js";
-import { requireInteractiveTerminal, unwrapPromptResult } from "./interactive.js";
-export async function confirmReset(input = process.stdin, output = process.stdout) {
-    requireInteractiveTerminal(input, output, "reset requires confirmation from a TTY. Re-run with --yes to skip the prompt.");
-    const confirmed = await clack.confirm({
-        message: "This will remove CompanyHelm containers, Postgres data, generated runtime files under ~/.companyhelm/cli/runtime, and the CLI workspace config under ~/.companyhelm/cli/config.yaml. Continue?",
-        active: "Yes",
-        inactive: "No",
-        initialValue: false,
-        input,
-        output
-    });
-    return unwrapPromptResult(confirmed, "Reset cancelled.", output);
-}
-export async function confirmRemoveGithubAppConfig(store = new GithubAppConfigStore(), input = process.stdin, output = process.stdout) {
-    if (!store.hasConfig()) {
-        return false;
-    }
-    requireInteractiveTerminal(input, output, "reset requires confirmation from a TTY. Re-run with --yes to skip the prompt.");
-    const confirmed = await clack.confirm({
-        message: `Also remove the machine GitHub App config at ${store.configPath()}?`,
-        active: "Remove it",
-        inactive: "Keep it",
-        initialValue: false,
-        input,
-        output
-    });
-    return unwrapPromptResult(confirmed, "Reset cancelled.", output);
-}
-export function registerResetCommand(program, dependencies) {
-    program
-        .command("reset")
-        .description("Destroy the local deployment state.")
-        .option("-y, --yes", "Skip the confirmation prompt.")
-        .option("--remove-github-app-config", "Also remove the machine GitHub App config.")
-        .action(async (options) => {
-        let removeGithubAppConfig = Boolean(options.removeGithubAppConfig);
-        if (!options.yes) {
-            const confirmed = await confirmReset();
-            if (!confirmed) {
-                clack.cancel("Reset cancelled.");
-                return;
-            }
-            if (!removeGithubAppConfig) {
-                removeGithubAppConfig = await confirmRemoveGithubAppConfig();
-            }
-        }
-        await dependencies.reset({ removeGithubAppConfig });
-    });
-}

package/dist/commands/set-image-version.d.ts

@@ -1,31 +0,0 @@
-import type { Readable, Writable } from "node:stream";
-import type { Command } from "commander";
-import { type ManagedImageService } from "../core/runtime/ManagedImages.js";
-export interface SetImageVersionOptions {
-    service?: string;
-    limit: number;
-}
-export interface AvailableImageTag {
-    tag: string;
-    createdAt?: string;
-}
-export interface InteractiveImageSelector {
-    listAvailableTags(service: ManagedImageService, limit: number): Promise<AvailableImageTag[]>;
-    buildImageReference(service: ManagedImageService, tag: string): string;
-}
-export interface ImageVersionStore {
-    load(): {
-        images: Partial<Record<ManagedImageService, string>>;
-    };
-    setImage(service: ManagedImageService, image: string): {
-        configPath: string;
-        image: string;
-    };
-}
-export declare function runSetImageVersion(options: SetImageVersionOptions, dependencies?: {
-    input?: Readable;
-    output?: Writable;
-    registry?: InteractiveImageSelector;
-    configStore?: ImageVersionStore;
-}): Promise<void>;
-export declare function registerSetImageVersionCommand(program: Command): void;

package/dist/commands/set-image-version.js

@@ -1,87 +0,0 @@
-import * as clack from "@clack/prompts";
-import { MANAGED_IMAGE_SERVICES, requireManagedImageService } from "../core/runtime/ManagedImages.js";
-import { PublicImageTagRegistry } from "../core/runtime/PublicImageTagRegistry.js";
-import { ImageConfigStore } from "../core/runtime/ImageConfigStore.js";
-import { requireInteractiveTerminal, unwrapPromptResult } from "./interactive.js";
-function parsePositiveInteger(value) {
-    const parsed = Number.parseInt(value, 10);
-    if (!Number.isInteger(parsed) || parsed < 1) {
-        throw new Error(`Expected a positive integer, received: ${value}`);
-    }
-    return parsed;
-}
-async function promptForSelection(message, options, input, output, defaultValue) {
-    requireInteractiveTerminal(input, output, "set-image-version requires a TTY so you can choose an image interactively.");
-    if (options.length === 0) {
-        throw new Error("No selectable options were provided.");
-    }
-    const selected = await clack.select({
-        message,
-        options: options.map((option, index) => ({
-            ...option,
-            hint: option.value === defaultValue ? "current" : undefined
-        })),
-        initialValue: defaultValue,
-        input,
-        output
-    });
-    return unwrapPromptResult(selected, "Image selection cancelled.", output);
-}
-async function loadAvailableTags(registry, service, limit, output) {
-    const spinner = clack.spinner({ output });
-    spinner.start(`Loading the latest ${limit} image tags for ${service}`);
-    let tags;
-    try {
-        tags = await registry.listAvailableTags(service, limit);
-    }
-    catch (error) {
-        spinner.stop("Unable to load image tags");
-        throw error;
-    }
-    if (tags.length === 0) {
-        spinner.stop("No image tags found");
-        throw new Error(`No image tags found for ${service}.`);
-    }
-    spinner.stop(`Loaded ${tags.length} image tag${tags.length === 1 ? "" : "s"}`);
-    return tags;
-}
-function formatTagTimestamp(createdAt) {
-    if (!createdAt) {
-        return "timestamp unavailable";
-    }
-    const timestamp = new Date(createdAt);
-    if (Number.isNaN(timestamp.valueOf())) {
-        return "timestamp unavailable";
-    }
-    return timestamp.toISOString().slice(0, 16).replace("T", " ") + " UTC";
-}
-export async function runSetImageVersion(options, dependencies = {}) {
-    const input = dependencies.input ?? process.stdin;
-    const output = dependencies.output ?? process.stdout;
-    const registry = dependencies.registry ?? new PublicImageTagRegistry();
-    const configStore = dependencies.configStore ?? new ImageConfigStore();
-    clack.intro("CompanyHelm image selection", { output });
-    const selectedService = options.service
-        ? requireManagedImageService(options.service)
-        : await promptForSelection("Which image do you want to pin?", MANAGED_IMAGE_SERVICES.map((service) => ({ value: service, label: service })), input, output).then((value) => requireManagedImageService(value));
-    const currentImage = configStore.load().images[selectedService];
-    clack.log.info(`Current configured image for ${selectedService}: ${currentImage ?? "default (latest)"}`, { output });
-    const tags = await loadAvailableTags(registry, selectedService, options.limit, output);
-    const currentTag = currentImage ? currentImage.slice(currentImage.lastIndexOf(":") + 1) : undefined;
-    const selectedTag = await promptForSelection(`Choose the ${selectedService} image tag`, tags.map((tag) => ({
-        value: tag.tag,
-        label: `${tag.tag} (${formatTagTimestamp(tag.createdAt)})`
-    })), input, output, currentTag);
-    const result = configStore.setImage(selectedService, registry.buildImageReference(selectedService, selectedTag));
-    clack.outro(`Updated ${result.configPath} to ${result.image}`, { output });
-}
-export function registerSetImageVersionCommand(program) {
-    program
-        .command("set-image-version")
-        .description("Interactively choose an API or frontend image tag and store it in the packaged image config.")
-        .option("-s, --service <service>", "Prefill the service to update (api or frontend)")
-        .option("-l, --limit <count>", "How many image tags to show", parsePositiveInteger, 20)
-        .action(async (options) => {
-        await runSetImageVersion(options);
-    });
-}

package/dist/commands/setup-github-app.d.ts

@@ -1,13 +0,0 @@
-import { Writable, type Readable } from "node:stream";
-import type { Command } from "commander";
-import { GithubAppConfigStore } from "../core/config/GithubAppConfigStore.js";
-import { type GithubAppConfig } from "../core/config/GithubAppConfig.js";
-import type { AgentWorkspaceMode } from "../core/runtime/LocalConfigStore.js";
-type BrowserUrlOpener = (url: string) => Promise<void>;
-export declare function readPemFromTerminal(input?: Readable, output?: Writable): Promise<string>;
-export declare function promptGithubAppConfig(input?: Readable, output?: Writable, openBrowser?: BrowserUrlOpener): Promise<GithubAppConfig>;
-export declare function ensureGithubAppConfig(store?: GithubAppConfigStore, input?: Readable, output?: Writable, options?: {
-    workspaceMode?: AgentWorkspaceMode;
-}): Promise<GithubAppConfig | null>;
-export declare function registerSetupGithubAppCommand(program: Command, store?: GithubAppConfigStore): void;
-export {};