@companyhelm/cli 0.1.2 → 0.1.5

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,28 @@
+import { type RuntimeVersions } from "../core/runtime/VersionCatalog.js";
 import { type StatusSnapshot } from "../core/status/StatusService.js";
+export type LogLevel = "debug" | "info" | "warn" | "error";
+export type LocalRepoOptionValue = string | true | undefined;
+export interface UpOptions {
+    logLevel?: LogLevel;
+    useHostDockerRuntime?: boolean;
+    apiRepoPath?: LocalRepoOptionValue;
+    webRepoPath?: LocalRepoOptionValue;
+}
+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,24 @@ 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 { 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 { 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 +32,38 @@ 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 localRepoSourceResolver = new LocalRepoSourceResolver(process.cwd());
+    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())) {
@@ -31,34 +71,140 @@ export function createDefaultDependencies() {
             }
             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() {
+        async up(options = {}) {
+            const logLevel = options.logLevel ?? "info";
+            const useHostDockerRuntime = options.useHostDockerRuntime ?? false;
+            const githubAppConfig = await ensureGithubAppConfig(githubAppConfigStore, process.stdin, process.stdout);
             const state = stateStore.initialize();
+            process.stdout.write(`${renderer.renderBanner()}\n`);
+            const runnerAlreadyRunning = await isRunnerRunning(commandRunner, runnerSupervisor);
+            const desiredSources = localRepoSourceResolver.resolve(options);
+            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);
-            bootstrapper.writeFrontendConfig(root, state);
-            process.stdout.write(`${renderer.renderBanner()}\n`);
-            await dockerStackManager.up(state);
-            await dockerStackManager.applySeedSql();
-            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
+            bootstrapper.writeApiConfig(root, state, logLevel, {
+                databaseHost: desiredSources.api.source === "local" ? "127.0.0.1" : "postgres"
             });
-            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`);
+            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: `127.0.0.1:${state.ports.agentCliGrpc}`,
+                        logPath: runtimePaths.runnerLogPath(),
+                        secret: state.runner.secret,
+                        logLevel,
+                        useHostDockerRuntime
+                    });
+                    process.stdout.write(`${renderer.progress("Starting the runner...")}\n`);
+                    await commandRunner.run(startCommand.command, startCommand.args);
+                    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() {
-            if (!stateStore.load()) {
-                return;
-            }
             const stopCommand = runnerSupervisor.buildStopArgs();
             try {
                 await commandRunner.run(stopCommand.command, stopCommand.args);
@@ -66,17 +212,66 @@ export function createDefaultDependencies() {
             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();
         },
-        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 = {}) {
+            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(projectPaths.apiEnvPath(), { 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/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;