@companyhelm/cli 0.0.12 → 0.1.4

package/README.md

@@ -1,58 +1,61 @@
-# CompanyHelm CLI
+# CompanyHelm - Distributed AI Agent Orchestration
 
-Run coding agents in isolated Docker sandboxes on your machine.
+CompanyHelm is an open-source control plane for running AI-agent companies in your own infrastructure.
+It gives teams a way to organize agents by role, keep humans in the loop for approvals and clarification, and run agent workloads in isolated environments instead of opaque hosted black boxes. Each agent can run its own app infrastructure for testing and create PRs autonomously. Spin up container-isolated agent threads with a click.
 
-## Install
+[Website](https://www.companyhelm.com/)
 
-```bash
-npm install -g @companyhelm/cli
-```
+## Quick start
 
-Or run it without installing globally:
+Dependecies:
+- Docker
+- Node.js `>=24`
+- Codex subscription or api key
+- Github account
 
 ```bash
-npx @companyhelm/cli --help
+npx @companyhelm/cli up
 ```
 
-Package: [@companyhelm/cli](https://www.npmjs.com/package/@companyhelm/cli)
-
-## Basic Usage
+After startup, the CLI prints:
 
-Start the CLI in the foreground:
+- the local dashboard UI URL
+- the generated username and password
 
-```bash
-companyhelm-runner
-```
+## What CompanyHelm is
 
-Start it as a daemon:
-
-```bash
-companyhelm-runner --daemon
-```
+From the product perspective, CompanyHelm is built around a few core ideas:
 
-Check whether the daemon is running:
+- Your infrastructure, not a vendor-controlled runtime
+- Model-agnostic agent execution through open runners and protocols
+- Easy agent customization: add skills, MCP servers, and custom instructions to agents from the UI
+- Human-in-the-loop workflows: tasks can be steered at any moment through the built-in chat; approvals and questions are still a work in progress
+- Isolated execution so agents can work in parallel with minimal interference. Each runner can spin up the full app infrastructure within Docker and test in isolation
+- YOLO mode by default: agents run commands without pausing for trivial confirmations
+- Remote repository as the source of truth: agents clone the repo and submit PRs automatically
+- Parallel task execution: multiple agents can execute tasks independently in isolated environments
 
-```bash
-companyhelm-runner status
-```
+## What the CLI boots locally
 
-The `status` command prints:
+`npx @companyhelm/cli up` brings up a local CompanyHelm stack with:
 
-- whether the daemon is running
-- the recorded daemon PID
-- the daemon log directory and log file path
+- CompanyHelm API
+- Postgres
+- CompanyHelm frontend
+- CompanyHelm agent runner
 
-## Why Use It
 
-- Runs agents in isolated containers instead of directly on your machine
-- Supports Docker-in-Docker for end-to-end workflows
-- Keeps runner state in a local SQLite database
-- Supports long-running daemon mode for background operation
+## Command reference
 
-## For Developers
+For the full CLI help:
 
-Development and maintenance notes live in [DEVELOPING.md](./DEVELOPING.md).
+```bash
+npx @companyhelm/cli --help
+```
 
-## License
+Common commands:
 
-MIT
+```bash
+npx @companyhelm/cli logs {service]
+npx @companyhelm/cli reset
+```

package/dist/cli.d.ts

@@ -0,0 +1 @@
+export declare function main(argv?: string[]): Promise<void>;

package/dist/cli.js

@@ -1,57 +1,18 @@
-#!/usr/bin/env node
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const node_fs_1 = require("node:fs");
-const node_path_1 = require("node:path");
-const commander_1 = require("commander");
-const global_options_js_1 = require("./commands/global-options.js");
-const register_commands_js_1 = require("./commands/register-commands.js");
-function getVersion() {
+import { buildProgram } from "./commands/register-commands.js";
+import { InteractiveCommandCancelledError } from "./commands/interactive.js";
+export async function main(argv = process.argv) {
+    const program = buildProgram();
     try {
-        const pkgPath = (0, node_path_1.join)(__dirname, "..", "package.json");
-        const pkg = JSON.parse((0, node_fs_1.readFileSync)(pkgPath, "utf8"));
-        return pkg.version ?? "0.0.0";
-    }
-    catch {
-        return "0.0.0";
-    }
-}
-const program = new commander_1.Command();
-program
-    .name("companyhelm")
-    .description("Run coding agents in fully isolated Docker sandboxes, locally.")
-    .version(getVersion());
-(0, global_options_js_1.addGlobalOptions)(program);
-(0, register_commands_js_1.registerCommands)(program);
-program.hook("preAction", (_thisCommand, actionCommand) => {
-    (0, global_options_js_1.applyGlobalOptionEnvironment)(actionCommand);
-});
-function formatCliError(error) {
-    if (error instanceof commander_1.CommanderError) {
-        return {
-            message: error.message,
-            exitCode: error.exitCode,
-        };
-    }
-    if (error instanceof Error) {
-        return {
-            message: error.message,
-            exitCode: 1,
-        };
-    }
-    return {
-        message: String(error),
-        exitCode: 1,
-    };
-}
-async function main() {
-    try {
-        await program.parseAsync(process.argv);
+        await program.parseAsync(argv);
     }
     catch (error) {
-        const { message, exitCode } = formatCliError(error);
-        process.stderr.write(`${message}\n`);
-        process.exitCode = exitCode;
+        if (error instanceof InteractiveCommandCancelledError) {
+            process.exitCode = 1;
+            return;
+        }
+        throw error;
     }
 }
-void main();
+if (import.meta.url === `file://${process.argv[1]}`) {
+    void main();
+}

package/dist/commands/dependencies.d.ts

@@ -0,0 +1,24 @@
+import { type RuntimeVersions } from "../core/runtime/VersionCatalog.js";
+import { type StatusSnapshot } from "../core/status/StatusService.js";
+export type LogLevel = "debug" | "info" | "warn" | "error";
+export interface UpOptions {
+    logLevel?: LogLevel;
+}
+export interface ResetOptions {
+    removeGithubAppConfig?: boolean;
+}
+export interface StatusReport {
+    services: StatusSnapshot;
+    apiUrl?: string;
+    uiUrl?: string;
+    username?: string;
+    versions?: RuntimeVersions;
+}
+export interface CommandDependencies {
+    up(options?: UpOptions): Promise<void>;
+    down(): Promise<void>;
+    status(): Promise<StatusReport>;
+    logs(service: string): Promise<void>;
+    reset(options?: ResetOptions): Promise<void>;
+}
+export declare function createDefaultDependencies(): CommandDependencies;

package/dist/commands/dependencies.js

@@ -0,0 +1,145 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+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 { LogsService } from "../core/logs/LogsService.js";
+import { CommandRunner } from "../core/process/CommandRunner.js";
+import { ProjectPaths } from "../core/runtime/ProjectPaths.js";
+import { RunnerSupervisor } from "../core/runner/RunnerSupervisor.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 { ensureGithubAppConfig } from "./setup-github-app.js";
+function runtimeRoot() {
+    return process.env.COMPANYHELM_HOME || path.join(os.homedir(), ".companyhelm");
+}
+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(process.cwd());
+    const projectPaths = new ProjectPaths(process.cwd());
+    const versionCatalog = new VersionCatalog();
+    const statusService = new StatusService(() => dockerStackManager.runningServices(), {
+        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;
+        }
+        await dockerStackManager.logs(service);
+    });
+    return {
+        async up(options = {}) {
+            const logLevel = options.logLevel ?? "info";
+            const githubAppConfig = await ensureGithubAppConfig(githubAppConfigStore, process.stdin, process.stdout);
+            const state = stateStore.initialize();
+            const versions = versionCatalog.resolve();
+            const passwordRecord = createPasswordHash(state.auth.password);
+            fs.mkdirSync(root, { recursive: true });
+            apiEnvFileWriter.write(githubAppConfig);
+            bootstrapper.writeSeedSql(root, state, passwordRecord.passwordHash, passwordRecord.passwordSalt);
+            bootstrapper.writeApiConfig(root, state, logLevel);
+            bootstrapper.writeFrontendConfig(root, state);
+            process.stdout.write(`${renderer.renderBanner()}\n`);
+            await dockerStackManager.up(state, { frontendLogLevel: logLevel });
+            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);
+            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: `127.0.0.1:${state.ports.agentCliGrpc}`,
+                logPath: runtimePaths.runnerLogPath(),
+                secret: state.runner.secret,
+                logLevel
+            });
+            process.stdout.write(`${renderer.progress("Starting the runner...")}\n`);
+            await commandRunner.run(startCommand.command, startCommand.args);
+            const apiUrl = `http://127.0.0.1:${state.ports.apiHttp}/graphql`;
+            const uiUrl = `http://127.0.0.1:${state.ports.ui}`;
+            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(`API image: ${versions.images.api}\n`);
+            process.stdout.write(`Frontend 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`);
+        },
+        async down() {
+            if (!stateStore.load()) {
+                return;
+            }
+            const stopCommand = runnerSupervisor.buildStopArgs();
+            try {
+                await commandRunner.run(stopCommand.command, stopCommand.args);
+            }
+            catch {
+                // Ignore runner stop failures during teardown so container cleanup still happens.
+            }
+            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 = {}) {
+            if (stateStore.load()) {
+                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 dockerStackManager.down({ removeVolumes: true });
+            fs.rmSync(projectPaths.apiEnvPath(), { force: true });
+            fs.rmSync(root, { recursive: true, force: true });
+            if (options.removeGithubAppConfig) {
+                githubAppConfigStore.delete();
+            }
+        }
+    };
+}

package/dist/commands/down.d.ts

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

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

package/dist/commands/interactive.d.ts

@@ -0,0 +1,6 @@
+import type { Readable, Writable } from "node:stream";
+export declare class InteractiveCommandCancelledError extends Error {
+    constructor(message: string);
+}
+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

@@ -0,0 +1,22 @@
+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 requireInteractiveTerminal(input, output, message) {
+    if (!isReadableTty(input) || !clack.isTTY(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

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

@@ -0,0 +1,14 @@
+const AVAILABLE_LOG_SERVICES = ["postgres", "api", "frontend", "runner"];
+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_LOG_SERVICES.map((name) => `- ${name}`).join("\n")}\n`);
+            return;
+        }
+        await dependencies.logs(service);
+    });
+}

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

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

package/dist/commands/register-commands.js

@@ -1,15 +1,20 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.registerCommands = registerCommands;
-const register_runner_commands_js_1 = require("./runner/register-runner-commands.js");
-const shell_js_1 = require("./shell.js");
-const register_sdk_commands_js_1 = require("./sdk/register-sdk-commands.js");
-const status_js_1 = require("./status.js");
-const register_thread_commands_js_1 = require("./thread/register-thread-commands.js");
-function registerCommands(program) {
-    (0, register_runner_commands_js_1.registerRunnerCommands)(program);
-    (0, status_js_1.registerStatusCommand)(program);
-    (0, register_thread_commands_js_1.registerThreadCommands)(program);
-    (0, shell_js_1.registerShellCommand)(program);
-    (0, register_sdk_commands_js_1.registerSdkCommands)(program);
+import { Command } from "commander";
+import { createDefaultDependencies } from "./dependencies.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");
+    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

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

@@ -0,0 +1,51 @@
+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, local runtime state, and generated .companyhelm/api/.env. 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

@@ -0,0 +1,31 @@
+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 ImageConfigStore {
+    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?: ImageConfigStore;
+}): Promise<void>;
+export declare function registerSetImageVersionCommand(program: Command): void;

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

@@ -0,0 +1,87 @@
+import * as clack from "@clack/prompts";
+import { LocalConfigStore } from "../core/runtime/LocalConfigStore.js";
+import { MANAGED_IMAGE_SERVICES, requireManagedImageService } from "../core/runtime/ManagedImages.js";
+import { PublicImageTagRegistry } from "../core/runtime/PublicImageTagRegistry.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 LocalConfigStore();
+    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 local config.yaml.")
+        .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

@@ -0,0 +1,10 @@
+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";
+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): Promise<GithubAppConfig>;
+export declare function registerSetupGithubAppCommand(program: Command, store?: GithubAppConfigStore): void;
+export {};