@companyhelm/cli 0.0.11 → 0.1.2

package/README.md

@@ -1,58 +1,54 @@
 # CompanyHelm CLI
 
-Run coding agents in isolated Docker sandboxes on your machine.
+Bootstrap and manage a local CompanyHelm deployment.
 
-## Install
+## Commands
 
-```bash
-npm install -g @companyhelm/cli
-```
-
-Or run it without installing globally:
+Start or reconcile the local deployment:
 
 ```bash
-npx @companyhelm/cli --help
+npx @companyhelm/cli up
 ```
 
-Package: [@companyhelm/cli](https://www.npmjs.com/package/@companyhelm/cli)
-
-## Basic Usage
-
-Start the CLI in the foreground:
+Stop the local deployment:
 
 ```bash
-companyhelm-runner
+npx @companyhelm/cli down
 ```
 
-Start it as a daemon:
+Show the current service status:
 
 ```bash
-companyhelm-runner --daemon
+npx @companyhelm/cli status
 ```
 
-Check whether the daemon is running:
+Show logs for one managed service:
 
 ```bash
-companyhelm-runner status
+npx @companyhelm/cli logs <service>
 ```
 
-The `status` command prints:
+Supported services:
+
+- `postgres`
+- `api`
+- `frontend`
+- `runner`
 
-- whether the daemon is running
-- the recorded daemon PID
-- the daemon log directory and log file path
+Destroy the local deployment and generated state:
 
-## Why Use It
+```bash
+npx @companyhelm/cli reset --force
+```
 
-- 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
+## Authentication
 
-## For Developers
+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.
 
-Development and maintenance notes live in [DEVELOPING.md](./DEVELOPING.md).
+## Image Overrides
 
-## License
+The packaged stack can be overridden with environment variables:
 
-MIT
+- `COMPANYHELM_API_IMAGE`
+- `COMPANYHELM_WEB_IMAGE`
+- `COMPANYHELM_POSTGRES_IMAGE`

package/dist/cli.d.ts

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

package/dist/cli.js

@@ -1,57 +1,8 @@
-#!/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() {
-    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";
-    }
+import { buildProgram } from "./commands/register-commands.js";
+export async function main(argv = process.argv) {
+    const program = buildProgram();
+    await program.parseAsync(argv);
 }
-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,
-    };
+if (import.meta.url === `file://${process.argv[1]}`) {
+    void main();
 }
-async function main() {
-    try {
-        await program.parseAsync(process.argv);
-    }
-    catch (error) {
-        const { message, exitCode } = formatCliError(error);
-        process.stderr.write(`${message}\n`);
-        process.exitCode = exitCode;
-    }
-}
-void main();

package/dist/commands/dependencies.d.ts

@@ -0,0 +1,9 @@
+import { type StatusSnapshot } from "../core/status/StatusService.js";
+export interface CommandDependencies {
+    up(): Promise<void>;
+    down(): Promise<void>;
+    status(): Promise<StatusSnapshot>;
+    logs(service: string): Promise<void>;
+    reset(): Promise<void>;
+}
+export declare function createDefaultDependencies(): CommandDependencies;

package/dist/commands/dependencies.js

@@ -0,0 +1,82 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { DeploymentBootstrapper } from "../core/bootstrap/DeploymentBootstrapper.js";
+import { DockerStackManager } from "../core/docker/DockerStackManager.js";
+import { LogsService } from "../core/logs/LogsService.js";
+import { CommandRunner } from "../core/process/CommandRunner.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 { StatusService } from "../core/status/StatusService.js";
+import { TerminalRenderer } from "../core/ui/TerminalRenderer.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 statusService = new StatusService(() => dockerStackManager.runningServices());
+    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() {
+            const state = stateStore.initialize();
+            const passwordRecord = createPasswordHash(state.auth.password);
+            fs.mkdirSync(root, { recursive: true });
+            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
+            });
+            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`);
+        },
+        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();
+        },
+        status() {
+            return statusService.read();
+        },
+        logs(service) {
+            return logsService.stream(service);
+        },
+        async reset() {
+            await this.down();
+            fs.rmSync(root, { recursive: true, force: true });
+        }
+    };
+}

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/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,9 @@
+export function registerLogsCommand(program, dependencies) {
+    program
+        .command("logs")
+        .description("Show logs for a managed service.")
+        .argument("<service>")
+        .action(async (service) => {
+        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,16 @@
-"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 { registerStatusCommand } from "./status.js";
+import { registerUpCommand } from "./up.js";
+export function buildProgram(dependencies = createDefaultDependencies()) {
+    const program = new Command().name("companyhelm");
+    registerUpCommand(program, dependencies);
+    registerDownCommand(program, dependencies);
+    registerStatusCommand(program, dependencies);
+    registerLogsCommand(program, dependencies);
+    registerResetCommand(program, dependencies);
+    return program;
 }

package/dist/commands/reset.d.ts

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

package/dist/commands/reset.js

@@ -0,0 +1,12 @@
+export function registerResetCommand(program, dependencies) {
+    program
+        .command("reset")
+        .description("Destroy the local deployment state.")
+        .option("--force")
+        .action(async (options) => {
+        if (!options.force) {
+            throw new Error("reset requires --force");
+        }
+        await dependencies.reset();
+    });
+}

package/dist/commands/status.d.ts

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

package/dist/commands/status.js

@@ -1,32 +1,5 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.registerStatusCommand = registerStatusCommand;
-const node_path_1 = require("node:path");
-const config_js_1 = require("../config.js");
-const daemon_state_js_1 = require("../state/daemon_state.js");
-const daemon_js_1 = require("../utils/daemon.js");
-const process_js_1 = require("../utils/process.js");
-function registerStatusCommand(program) {
-    program
-        .command("status")
-        .description("Show whether the local CompanyHelm daemon is running.")
-        .option("--state-db-path <path>", "State database path override (defaults to state.db under the active config directory).")
-        .action(async (options) => {
-        const cfg = config_js_1.config.parse({
-            state_db_path: options.stateDbPath,
-        });
-        const state = await (0, daemon_state_js_1.readCurrentDaemonState)(cfg.state_db_path);
-        const running = state?.pid != null && (0, process_js_1.isProcessRunning)(state.pid);
-        const logPath = state?.logPath ?? (0, daemon_js_1.resolveDaemonLogPath)(cfg.state_db_path);
-        const logDirectory = state?.logPath ? (0, node_path_1.dirname)(state.logPath) : (0, daemon_js_1.resolveDaemonLogDirectory)(cfg.state_db_path);
-        console.log(`Daemon: ${running ? "running" : "not running"}`);
-        if (state?.pid != null) {
-            console.log(`PID: ${running ? state.pid : `${state.pid} (stale)`}`);
-        }
-        else {
-            console.log("PID: none");
-        }
-        console.log(`Log directory: ${logDirectory}`);
-        console.log(`Log file: ${logPath}`);
+export function registerStatusCommand(program, dependencies) {
+    program.command("status").description("Show deployment status.").action(async () => {
+        process.stdout.write(`${JSON.stringify(await dependencies.status())}\n`);
     });
 }

package/dist/commands/up.d.ts

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

package/dist/commands/up.js

@@ -0,0 +1,5 @@
+export function registerUpCommand(program, dependencies) {
+    program.command("up").description("Start or reconcile the local deployment.").action(async () => {
+        await dependencies.up();
+    });
+}

package/dist/core/bootstrap/DeploymentBootstrapper.d.ts

@@ -0,0 +1,9 @@
+import type { RuntimeState } from "../runtime/RuntimeState.js";
+export declare class DeploymentBootstrapper {
+    private readonly renderer;
+    private readonly githubAppClientId;
+    writeSeedSql(root: string, state: RuntimeState, passwordHash: string, passwordSalt: string): string;
+    writeApiConfig(root: string, state: RuntimeState): string;
+    writeFrontendConfig(root: string, state: RuntimeState): string;
+    private indentBlock;
+}

package/dist/core/bootstrap/DeploymentBootstrapper.js

@@ -0,0 +1,101 @@
+import fs from "node:fs";
+import { RuntimePaths } from "../runtime/RuntimePaths.js";
+import { SeedSqlRenderer } from "./SeedSqlRenderer.js";
+export class DeploymentBootstrapper {
+    renderer = new SeedSqlRenderer();
+    githubAppClientId = "Iv23lirb9vZAi67f5bSQ";
+    writeSeedSql(root, state, passwordHash, passwordSalt) {
+        const runtimePaths = new RuntimePaths(root);
+        const outputPath = runtimePaths.seedFilePath();
+        const sql = this.renderer.render({
+            companyId: state.company.id,
+            companyName: state.company.name,
+            username: state.auth.username,
+            passwordHash,
+            passwordSalt,
+            runnerName: state.runner.name,
+            runnerSecret: state.runner.secret
+        });
+        fs.writeFileSync(outputPath, sql, "utf8");
+        return outputPath;
+    }
+    writeApiConfig(root, state) {
+        const runtimePaths = new RuntimePaths(root);
+        const outputPath = runtimePaths.apiConfigPath();
+        const yaml = [
+            "app:",
+            '  host: "0.0.0.0"',
+            '  port: 4000',
+            '  graphqlEndpoint: "/graphql"',
+            "  graphiql: true",
+            "  grpc:",
+            '    host: "0.0.0.0"',
+            "    port: 50051",
+            "    heartbeat:",
+            "      intervalMs: 20000",
+            "      jitterMs: 10000",
+            "agent:",
+            "  grpc:",
+            '    host: "0.0.0.0"',
+            "    port: 50052",
+            "database:",
+            '  name: "companyhelm"',
+            '  host: "postgres"',
+            "  port: 5432",
+            "  roles:",
+            "    app_runtime:",
+            '      username: "app-runtime"',
+            '      password: "companyhelm-local-app-runtime-role-password"',
+            "    admin:",
+            '      username: "postgres"',
+            '      password: "postgres"',
+            "github:",
+            `  app_client_id: "${this.githubAppClientId}"`,
+            "  app_private_key_pem: |-",
+            this.indentBlock(state.auth.jwtPrivateKeyPem, 4),
+            '  app_link: "https://github.com/apps/companyhelm-local"',
+            'authProvider: "companyhelm"',
+            "auth:",
+            "  companyhelm:",
+            "    jwt_private_key_pem: |-",
+            this.indentBlock(state.auth.jwtPrivateKeyPem, 6),
+            "    jwt_public_key_pem: |-",
+            this.indentBlock(state.auth.jwtPublicKeyPem, 6),
+            '    jwt_issuer: "companyhelm.local"',
+            '    jwt_audience: "companyhelm-web"',
+            "    jwt_expiration_seconds: 86400",
+            "security:",
+            "  encryption:",
+            '    key: "companyhelm-local-encryption-key"',
+            'log_level: "info"',
+            "log_pretty: false",
+            ""
+        ].join("\n");
+        fs.writeFileSync(outputPath, yaml, "utf8");
+        return outputPath;
+    }
+    writeFrontendConfig(root, state) {
+        const runtimePaths = new RuntimePaths(root);
+        const outputPath = runtimePaths.frontendConfigPath();
+        const yaml = [
+            "api:",
+            `  graphqlApiUrl: "http://127.0.0.1:${state.ports.apiHttp}/graphql"`,
+            `  runnerGrpcTarget: "localhost:${state.ports.runnerGrpc}"`,
+            "auth:",
+            '  provider: "companyhelm"',
+            "  companyhelm:",
+            '    tokenStorageKey: "companyhelm.auth.token"',
+            ""
+        ].join("\n");
+        fs.writeFileSync(outputPath, yaml, "utf8");
+        return outputPath;
+    }
+    indentBlock(value, spaces) {
+        const prefix = " ".repeat(spaces);
+        return value
+            .trimEnd()
+            .split("\n")
+            .map((line) => `${prefix}${line}`)
+            .join("\n");
+    }
+}

package/dist/core/bootstrap/SeedSqlRenderer.d.ts

@@ -0,0 +1,12 @@
+export interface SeedSqlInput {
+    companyId: string;
+    companyName: string;
+    username: string;
+    passwordHash: string;
+    passwordSalt?: string;
+    runnerName: string;
+    runnerSecret: string;
+}
+export declare class SeedSqlRenderer {
+    render(input: SeedSqlInput): string;
+}

package/dist/core/bootstrap/SeedSqlRenderer.js

@@ -0,0 +1,26 @@
+import { createHash } from "node:crypto";
+import fs from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+export class SeedSqlRenderer {
+    render(input) {
+        const templatePath = path.resolve(__dirname, "../../templates/seed.sql.tpl");
+        const template = fs.readFileSync(templatePath, "utf8");
+        const email = `${input.username}@local.companyhelm`;
+        const runnerSecretHash = createHash("sha256").update(input.runnerSecret).digest("hex");
+        return template
+            .replaceAll("{{COMPANY_ID}}", input.companyId)
+            .replaceAll("{{COMPANY_NAME}}", input.companyName)
+            .replaceAll("{{USER_ID}}", `${input.companyId}-admin`)
+            .replaceAll("{{USER_AUTH_ID}}", `${input.companyId}-auth`)
+            .replaceAll("{{USER_FIRST_NAME}}", input.username)
+            .replaceAll("{{USER_EMAIL}}", email)
+            .replaceAll("{{PASSWORD_SALT}}", input.passwordSalt ?? "password-salt")
+            .replaceAll("{{PASSWORD_HASH}}", input.passwordHash)
+            .replaceAll("{{RUNNER_ID}}", `${input.companyId}-runner`)
+            .replaceAll("{{RUNNER_NAME}}", input.runnerName)
+            .replaceAll("{{RUNNER_SECRET_HASH}}", runnerSecretHash);
+    }
+}

package/dist/core/docker/ComposeTemplateRenderer.d.ts

@@ -0,0 +1,14 @@
+export interface ComposePorts {
+    apiHttpPort: number;
+    uiPort: number;
+    runnerGrpcPort: number;
+    agentCliGrpcPort: number;
+}
+export interface ComposePaths {
+    apiConfigPath: string;
+    frontendConfigPath: string;
+    seedFilePath: string;
+}
+export declare class ComposeTemplateRenderer {
+    render(ports: ComposePorts, paths: ComposePaths): string;
+}

package/dist/core/docker/ComposeTemplateRenderer.js

@@ -0,0 +1,24 @@
+import fs from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { ImageCatalog } from "../runtime/ImageCatalog.js";
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+export class ComposeTemplateRenderer {
+    render(ports, paths) {
+        const templatePath = path.resolve(__dirname, "../../templates/docker-compose.yaml.tpl");
+        const template = fs.readFileSync(templatePath, "utf8");
+        const images = new ImageCatalog().resolve();
+        return template
+            .replaceAll("{{API_IMAGE}}", images.api)
+            .replaceAll("{{FRONTEND_IMAGE}}", images.frontend)
+            .replaceAll("{{POSTGRES_IMAGE}}", images.postgres)
+            .replaceAll("{{API_CONFIG_PATH}}", paths.apiConfigPath)
+            .replaceAll("{{FRONTEND_CONFIG_PATH}}", paths.frontendConfigPath)
+            .replaceAll("{{SEED_FILE_PATH}}", paths.seedFilePath)
+            .replaceAll("{{API_HTTP_PORT}}", String(ports.apiHttpPort))
+            .replaceAll("{{UI_PORT}}", String(ports.uiPort))
+            .replaceAll("{{RUNNER_GRPC_PORT}}", String(ports.runnerGrpcPort))
+            .replaceAll("{{AGENT_CLI_GRPC_PORT}}", String(ports.agentCliGrpcPort));
+    }
+}

package/dist/core/docker/DockerStackManager.d.ts

@@ -0,0 +1,14 @@
+import { CommandRunner } from "../process/CommandRunner.js";
+import type { RuntimeState } from "../runtime/RuntimeState.js";
+import { ComposeTemplateRenderer } from "./ComposeTemplateRenderer.js";
+export declare class DockerStackManager {
+    private readonly commandRunner;
+    private readonly composeRenderer;
+    private readonly runtimePaths;
+    constructor(root: string, commandRunner?: CommandRunner, composeRenderer?: ComposeTemplateRenderer);
+    up(state: RuntimeState): Promise<void>;
+    applySeedSql(): Promise<void>;
+    down(): Promise<void>;
+    logs(service: "postgres" | "api" | "frontend"): Promise<void>;
+    runningServices(): Promise<string>;
+}