@companyhelm/cli 0.1.2 → 0.1.4

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 CompanyHelm
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,54 +1,61 @@
-# CompanyHelm CLI
+# CompanyHelm - Distributed AI Agent Orchestration
 
-Bootstrap and manage a local CompanyHelm deployment.
+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.
 
-## Commands
+[Website](https://www.companyhelm.com/)
 
-Start or reconcile the local deployment:
+## Quick start
+
+Dependecies:
+- Docker
+- Node.js `>=24`
+- Codex subscription or api key
+- Github account
 
 ```bash
 npx @companyhelm/cli up
 ```
 
-Stop the local deployment:
+After startup, the CLI prints:
 
-```bash
-npx @companyhelm/cli down
-```
+- the local dashboard UI URL
+- the generated username and password
 
-Show the current service status:
+## What CompanyHelm is
 
-```bash
-npx @companyhelm/cli status
-```
-
-Show logs for one managed service:
+From the product perspective, CompanyHelm is built around a few core ideas:
 
-```bash
-npx @companyhelm/cli logs <service>
-```
+- 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
 
-Supported services:
+## What the CLI boots locally
 
-- `postgres`
-- `api`
-- `frontend`
-- `runner`
+`npx @companyhelm/cli up` brings up a local CompanyHelm stack with:
 
-Destroy the local deployment and generated state:
+- CompanyHelm API
+- Postgres
+- CompanyHelm frontend
+- CompanyHelm agent runner
 
-```bash
-npx @companyhelm/cli reset --force
-```
 
-## Authentication
+## Command reference
 
-On first `npx @companyhelm/cli up`, the CLI generates a local `admin` account and a random password. The password is printed at startup and persisted in the local runtime state until `npx @companyhelm/cli reset --force` is run.
+For the full CLI help:
 
-## Image Overrides
+```bash
+npx @companyhelm/cli --help
+```
 
-The packaged stack can be overridden with environment variables:
+Common commands:
 
-- `COMPANYHELM_API_IMAGE`
-- `COMPANYHELM_WEB_IMAGE`
-- `COMPANYHELM_POSTGRES_IMAGE`
+```bash
+npx @companyhelm/cli logs {service]
+npx @companyhelm/cli reset
+```

package/dist/cli.js

@@ -1,7 +1,17 @@
 import { buildProgram } from "./commands/register-commands.js";
+import { InteractiveCommandCancelledError } from "./commands/interactive.js";
 export async function main(argv = process.argv) {
     const program = buildProgram();
-    await program.parseAsync(argv);
+    try {
+        await program.parseAsync(argv);
+    }
+    catch (error) {
+        if (error instanceof InteractiveCommandCancelledError) {
+            process.exitCode = 1;
+            return;
+        }
+        throw error;
+    }
 }
 if (import.meta.url === `file://${process.argv[1]}`) {
     void main();

package/dist/commands/dependencies.d.ts

@@ -1,9 +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(): Promise<void>;
+    up(options?: UpOptions): Promise<void>;
     down(): Promise<void>;
-    status(): Promise<StatusSnapshot>;
+    status(): Promise<StatusReport>;
     logs(service: string): Promise<void>;
-    reset(): Promise<void>;
+    reset(options?: ResetOptions): Promise<void>;
 }
 export declare function createDefaultDependencies(): CommandDependencies;

package/dist/commands/dependencies.js

@@ -2,15 +2,20 @@ 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");
 }
@@ -23,7 +28,22 @@ export function createDefaultDependencies() {
     const dockerStackManager = new DockerStackManager(root, commandRunner);
     const runnerSupervisor = new RunnerSupervisor(runtimePaths.runnerConfigPath());
     const bootstrapper = new DeploymentBootstrapper();
-    const statusService = new StatusService(() => dockerStackManager.runningServices());
+    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())) {
@@ -34,26 +54,48 @@ export function createDefaultDependencies() {
         await dockerStackManager.logs(service);
     });
     return {
-        async up() {
+        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);
+            bootstrapper.writeApiConfig(root, state, logLevel);
             bootstrapper.writeFrontendConfig(root, state);
             process.stdout.write(`${renderer.renderBanner()}\n`);
-            await dockerStackManager.up(state);
-            await dockerStackManager.applySeedSql();
+            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
+                secret: state.runner.secret,
+                logLevel
             });
+            process.stdout.write(`${renderer.progress("Starting the runner...")}\n`);
             await commandRunner.run(startCommand.command, startCommand.args);
-            process.stdout.write(`${renderer.success(`API: http://127.0.0.1:${state.ports.apiHttp}/graphql`)}\n`);
-            process.stdout.write(`${renderer.success(`UI: http://127.0.0.1:${state.ports.ui}`)}\n`);
-            process.stdout.write(`admin password: ${state.auth.password}\n`);
+            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()) {
@@ -68,15 +110,36 @@ export function createDefaultDependencies() {
             }
             await dockerStackManager.down();
         },
-        status() {
-            return statusService.read();
+        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() {
-            await this.down();
+        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/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.js

@@ -1,9 +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>")
+        .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.js

@@ -3,14 +3,18 @@ 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

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

@@ -1,12 +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("--force")
+        .option("-y, --yes", "Skip the confirmation prompt.")
+        .option("--remove-github-app-config", "Also remove the machine GitHub App config.")
         .action(async (options) => {
-        if (!options.force) {
-            throw new Error("reset requires --force");
+        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();
+        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 {};