@companyhelm/cli 0.4.1 → 0.4.3

package/dist/core/config/GithubAppConfigStore.js

@@ -1,57 +0,0 @@
-import fs from "node:fs";
-import path from "node:path";
-import { parse, stringify } from "yaml";
-import { normalizeGithubAppConfig } from "./GithubAppConfig.js";
-import { defaultCliConfigRoot } from "../runtime/CliRoot.js";
-function defaultConfigRoot() {
-    return defaultCliConfigRoot();
-}
-export class GithubAppConfigStore {
-    configRoot;
-    constructor(configRoot = defaultConfigRoot()) {
-        this.configRoot = configRoot;
-    }
-    configPath() {
-        return path.join(this.configRoot, "github-app.yaml");
-    }
-    hasConfig() {
-        return fs.existsSync(this.configPath());
-    }
-    save(config) {
-        const normalized = normalizeGithubAppConfig(config);
-        fs.mkdirSync(this.configRoot, { recursive: true });
-        const tempPath = `${this.configPath()}.tmp`;
-        const yaml = stringify({
-            app_url: normalized.appUrl,
-            app_client_id: normalized.appClientId,
-            app_private_key_pem: normalized.appPrivateKeyPem,
-        });
-        fs.writeFileSync(tempPath, yaml, { encoding: "utf8", mode: 0o600 });
-        fs.renameSync(tempPath, this.configPath());
-        return this.configPath();
-    }
-    load() {
-        if (!this.hasConfig()) {
-            return null;
-        }
-        const parsed = parse(fs.readFileSync(this.configPath(), "utf8"));
-        if (!parsed || typeof parsed !== "object") {
-            throw new Error(`Machine GitHub App config at ${this.configPath()} is invalid.`);
-        }
-        return normalizeGithubAppConfig({
-            appUrl: String(parsed.app_url || ""),
-            appClientId: String(parsed.app_client_id || ""),
-            appPrivateKeyPem: String(parsed.app_private_key_pem || ""),
-        });
-    }
-    loadOrThrow() {
-        const config = this.load();
-        if (!config) {
-            throw new Error(`GitHub App config is not set up. Run \`companyhelm setup-github-app\` to create ${this.configPath()}.`);
-        }
-        return config;
-    }
-    delete() {
-        fs.rmSync(this.configPath(), { force: true });
-    }
-}

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

@@ -1,22 +0,0 @@
-import type { LogLevel } from "../../commands/dependencies.js";
-export interface ComposePorts {
-    apiHttpPort: number;
-    uiPort: number;
-    runnerGrpcPort: number;
-    agentCliGrpcPort: number;
-}
-export interface ComposePaths {
-    apiConfigPath: string;
-    apiEnvPath: string;
-    frontendConfigPath: string;
-    seedFilePath: string;
-}
-export interface ComposeRenderOptions {
-    frontendLogLevel?: LogLevel;
-    includeApi?: boolean;
-    includeFrontend?: boolean;
-    exposePostgresPort?: boolean;
-}
-export declare class ComposeTemplateRenderer {
-    render(ports: ComposePorts, paths: ComposePaths, options?: ComposeRenderOptions): string;
-}

package/dist/core/docker/ComposeTemplateRenderer.js

@@ -1,66 +0,0 @@
-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, options = {}) {
-        const templatePath = path.resolve(__dirname, "../../templates/docker-compose.yaml.tpl");
-        const template = fs.readFileSync(templatePath, "utf8");
-        const images = new ImageCatalog().resolve();
-        const frontendLogLevel = options.frontendLogLevel ?? "info";
-        const includeApi = options.includeApi ?? true;
-        const includeFrontend = options.includeFrontend ?? true;
-        const postgresPortsBlock = options.exposePostgresPort ? [
-            "    ports:",
-            '      - "5432:5432"'
-        ].join("\n") : "";
-        const apiBlock = includeApi ? [
-            "  api:",
-            `    image: ${images.api}`,
-            "    platform: linux/amd64",
-            "    depends_on:",
-            "      - postgres",
-            "    env_file:",
-            `      - "${paths.apiEnvPath}"`,
-            "    environment:",
-            "      COMPANYHELM_CONFIG_PATH: /run/companyhelm/config.yaml",
-            "    ports:",
-            `      - "${ports.apiHttpPort}:4000"`,
-            `      - "${ports.runnerGrpcPort}:${ports.runnerGrpcPort}"`,
-            "    volumes:",
-            `      - "${paths.apiConfigPath}:/run/companyhelm/config.yaml:ro"`,
-            "    networks:",
-            "      - companyhelm"
-        ].join("\n") : "";
-        const frontendBlock = includeFrontend ? [
-            "  frontend:",
-            `    image: ${images.frontend}`,
-            ...(includeApi ? ["    depends_on:", "      - api"] : []),
-            "    environment:",
-            "      COMPANYHELM_CONFIG_PATH: /run/companyhelm/config.yaml",
-            `      COMPANYHELM_LOG_LEVEL: "${frontendLogLevel}"`,
-            `      PORT: "${ports.uiPort}"`,
-            `      npm_config_loglevel: "${frontendLogLevel}"`,
-            "    ports:",
-            `      - "${ports.uiPort}:${ports.uiPort}"`,
-            "    volumes:",
-            `      - "${paths.frontendConfigPath}:/run/companyhelm/config.yaml:ro"`,
-            "    networks:",
-            "      - companyhelm"
-        ].join("\n") : "";
-        return template
-            .replaceAll("{{POSTGRES_IMAGE}}", images.postgres)
-            .replace("{{POSTGRES_PORTS_BLOCK}}", postgresPortsBlock)
-            .replace("{{API_SERVICE_BLOCK}}", apiBlock)
-            .replaceAll("{{API_CONFIG_PATH}}", paths.apiConfigPath)
-            .replaceAll("{{API_ENV_PATH}}", paths.apiEnvPath)
-            .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))
-            .replace("{{FRONTEND_SERVICE_BLOCK}}", frontendBlock);
-    }
-}

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

@@ -1,29 +0,0 @@
-import type { LogLevel } from "../../commands/dependencies.js";
-import { CommandRunner } from "../process/CommandRunner.js";
-import type { RuntimeState } from "../runtime/RuntimeState.js";
-import { ComposeTemplateRenderer } from "./ComposeTemplateRenderer.js";
-export interface DockerStackUpOptions {
-    frontendLogLevel?: LogLevel;
-    includeApi?: boolean;
-    includeFrontend?: boolean;
-    exposePostgresPort?: boolean;
-}
-export interface DockerStackDownOptions {
-    removeVolumes?: boolean;
-}
-export declare class DockerStackManager {
-    private readonly commandRunner;
-    private readonly composeRenderer;
-    private static readonly BOOTSTRAP_RETRY_COUNT;
-    private static readonly BOOTSTRAP_RETRY_DELAY_MS;
-    private readonly runtimePaths;
-    constructor(root: string, commandRunner?: CommandRunner, composeRenderer?: ComposeTemplateRenderer);
-    up(state: RuntimeState, options?: DockerStackUpOptions): Promise<void>;
-    applySeedSql(seedEmail: string): Promise<void>;
-    private seedSchemaReady;
-    private seedAlreadyApplied;
-    private waitForNextBootstrapAttempt;
-    down(options?: DockerStackDownOptions): Promise<void>;
-    logs(service: "postgres" | "api" | "frontend"): Promise<void>;
-    runningServices(): Promise<string>;
-}

package/dist/core/docker/DockerStackManager.js

@@ -1,163 +0,0 @@
-import fs from "node:fs";
-import { CommandRunner } from "../process/CommandRunner.js";
-import { RuntimePaths } from "../runtime/RuntimePaths.js";
-import { ComposeTemplateRenderer } from "./ComposeTemplateRenderer.js";
-export class DockerStackManager {
-    commandRunner;
-    composeRenderer;
-    static BOOTSTRAP_RETRY_COUNT = 60;
-    static BOOTSTRAP_RETRY_DELAY_MS = 1000;
-    runtimePaths;
-    constructor(root, commandRunner = new CommandRunner(), composeRenderer = new ComposeTemplateRenderer()) {
-        this.commandRunner = commandRunner;
-        this.composeRenderer = composeRenderer;
-        this.runtimePaths = new RuntimePaths(root);
-    }
-    async up(state, options = {}) {
-        fs.mkdirSync(this.runtimePaths.runnerConfigPath(), { recursive: true });
-        fs.writeFileSync(this.runtimePaths.composeFilePath(), this.composeRenderer.render({
-            apiHttpPort: state.ports.apiHttp,
-            uiPort: state.ports.ui,
-            runnerGrpcPort: state.ports.runnerGrpc,
-            agentCliGrpcPort: state.ports.agentCliGrpc
-        }, {
-            apiConfigPath: this.runtimePaths.apiConfigPath(),
-            apiEnvPath: this.runtimePaths.apiEnvPath(),
-            frontendConfigPath: this.runtimePaths.frontendConfigPath(),
-            seedFilePath: this.runtimePaths.seedFilePath()
-        }, {
-            frontendLogLevel: options.frontendLogLevel,
-            includeApi: options.includeApi,
-            includeFrontend: options.includeFrontend,
-            exposePostgresPort: options.exposePostgresPort
-        }), "utf8");
-        await this.commandRunner.run("docker", [
-            "compose",
-            "-f",
-            this.runtimePaths.composeFilePath(),
-            "up",
-            "-d"
-        ]);
-    }
-    async applySeedSql(seedEmail) {
-        if (!fs.existsSync(this.runtimePaths.seedFilePath())) {
-            return;
-        }
-        let lastError = null;
-        for (let attempt = 0; attempt < DockerStackManager.BOOTSTRAP_RETRY_COUNT; attempt += 1) {
-            try {
-                if (!(await this.seedSchemaReady())) {
-                    await this.waitForNextBootstrapAttempt();
-                    continue;
-                }
-                if (await this.seedAlreadyApplied(seedEmail)) {
-                    return;
-                }
-                await this.commandRunner.run("docker", [
-                    "compose",
-                    "-f",
-                    this.runtimePaths.composeFilePath(),
-                    "exec",
-                    "-T",
-                    "postgres",
-                    "psql",
-                    "-U",
-                    "postgres",
-                    "-d",
-                    "companyhelm",
-                    "-f",
-                    "/run/companyhelm/seed.sql"
-                ]);
-                return;
-            }
-            catch (error) {
-                lastError = error;
-                await this.waitForNextBootstrapAttempt();
-            }
-        }
-        throw lastError ?? new Error("Failed to apply seed SQL.");
-    }
-    async seedSchemaReady() {
-        const output = await this.commandRunner.capture("docker", [
-            "compose",
-            "-f",
-            this.runtimePaths.composeFilePath(),
-            "exec",
-            "-T",
-            "postgres",
-            "psql",
-            "-U",
-            "postgres",
-            "-d",
-            "companyhelm",
-            "-tAc",
-            "SELECT to_regclass('public.user_auths') IS NOT NULL"
-        ]);
-        return output.trim() === "t";
-    }
-    async seedAlreadyApplied(seedEmail) {
-        const escapedEmail = seedEmail.replaceAll("'", "''");
-        const output = await this.commandRunner.capture("docker", [
-            "compose",
-            "-f",
-            this.runtimePaths.composeFilePath(),
-            "exec",
-            "-T",
-            "postgres",
-            "psql",
-            "-U",
-            "postgres",
-            "-d",
-            "companyhelm",
-            "-tAc",
-            `SELECT 1 FROM user_auths WHERE email = '${escapedEmail}' LIMIT 1`
-        ]);
-        return output.trim() === "1";
-    }
-    async waitForNextBootstrapAttempt() {
-        await new Promise((resolve) => {
-            setTimeout(resolve, DockerStackManager.BOOTSTRAP_RETRY_DELAY_MS);
-        });
-    }
-    async down(options = {}) {
-        if (!fs.existsSync(this.runtimePaths.composeFilePath())) {
-            return;
-        }
-        const args = [
-            "compose",
-            "-f",
-            this.runtimePaths.composeFilePath(),
-            "down",
-            "--remove-orphans"
-        ];
-        if (options.removeVolumes) {
-            args.push("--volumes");
-        }
-        await this.commandRunner.run("docker", [
-            ...args
-        ]);
-    }
-    async logs(service) {
-        await this.commandRunner.run("docker", [
-            "compose",
-            "-f",
-            this.runtimePaths.composeFilePath(),
-            "logs",
-            service
-        ]);
-    }
-    async runningServices() {
-        if (!fs.existsSync(this.runtimePaths.composeFilePath())) {
-            return "";
-        }
-        return this.commandRunner.capture("docker", [
-            "compose",
-            "-f",
-            this.runtimePaths.composeFilePath(),
-            "ps",
-            "--services",
-            "--status",
-            "running"
-        ]);
-    }
-}

package/dist/core/local/ApiLocalService.d.ts

@@ -1,22 +0,0 @@
-import { LocalServiceProcessManager } from "./LocalServiceProcessManager.js";
-import { CommandRunner } from "../process/CommandRunner.js";
-import type { LogLevel } from "../../commands/dependencies.js";
-import type { GithubAppConfig } from "../config/GithubAppConfig.js";
-import type { LocalManagedServiceRuntime, RuntimeState } from "../runtime/RuntimeState.js";
-export interface ApiLocalServiceStartInput {
-    repoPath: string;
-    configPath: string;
-    graphqlUrl: string;
-    logPath: string;
-    githubAppConfig: GithubAppConfig | null;
-    state: RuntimeState;
-    logLevel: LogLevel;
-}
-export declare class ApiLocalService {
-    private readonly processManager;
-    private readonly commandRunner;
-    constructor(processManager?: LocalServiceProcessManager, commandRunner?: CommandRunner);
-    start(input: ApiLocalServiceStartInput): Promise<LocalManagedServiceRuntime>;
-    private ensureNodeModules;
-    private waitForReadiness;
-}

package/dist/core/local/ApiLocalService.js

@@ -1,65 +0,0 @@
-import fs from "node:fs";
-import { LocalServiceProcessManager } from "./LocalServiceProcessManager.js";
-import { CommandRunner } from "../process/CommandRunner.js";
-export class ApiLocalService {
-    processManager;
-    commandRunner;
-    constructor(processManager = new LocalServiceProcessManager(), commandRunner = new CommandRunner()) {
-        this.processManager = processManager;
-        this.commandRunner = commandRunner;
-    }
-    async start(input) {
-        await this.ensureNodeModules(input.repoPath);
-        const runtime = this.processManager.start({
-            serviceName: "api",
-            repoPath: input.repoPath,
-            command: process.execPath,
-            args: [
-                "./node_modules/tsx/dist/cli.mjs",
-                "watch",
-                "src/server.ts",
-                "--config-path",
-                input.configPath
-            ],
-            logPath: input.logPath,
-            env: {
-                APP_ENV: "local",
-                GITHUB_APP_CLIENT_ID: input.githubAppConfig?.appClientId ?? "",
-                GITHUB_APP_URL: input.githubAppConfig?.appUrl ?? "",
-                GITHUB_APP_PRIVATE_KEY_PEM: input.githubAppConfig?.appPrivateKeyPem ?? "",
-                COMPANYHELM_JWT_PRIVATE_KEY_PEM: input.state.auth.jwtPrivateKeyPem,
-                COMPANYHELM_JWT_PUBLIC_KEY_PEM: input.state.auth.jwtPublicKeyPem,
-                COMPANYHELM_LOG_LEVEL: input.logLevel
-            }
-        });
-        await this.waitForReadiness(input.graphqlUrl, runtime, "API");
-        return runtime;
-    }
-    async ensureNodeModules(repoPath) {
-        if (fs.existsSync(`${repoPath}/node_modules`)) {
-            return;
-        }
-        await this.commandRunner.run("npm", ["install"], repoPath);
-    }
-    async waitForReadiness(url, runtime, serviceName) {
-        const deadline = Date.now() + 60_000;
-        while (Date.now() < deadline) {
-            if (!this.processManager.isRunning(runtime)) {
-                throw new Error(`${serviceName} exited before becoming ready.`);
-            }
-            try {
-                const response = await fetch(url, { method: "OPTIONS" });
-                if (response.ok) {
-                    return;
-                }
-            }
-            catch {
-                // Retry until the deadline.
-            }
-            await new Promise((resolve) => {
-                setTimeout(resolve, 1000);
-            });
-        }
-        throw new Error(`${serviceName} did not become ready: ${url}`);
-    }
-}

package/dist/core/local/LocalRepoSourceResolver.d.ts

@@ -1,24 +0,0 @@
-import type { LocalRepoOptionValue } from "../../commands/dependencies.js";
-export interface DockerServiceSource {
-    source: "docker";
-}
-export interface LocalRepoServiceSource {
-    source: "local";
-    repoPath: string;
-}
-export type ResolvedServiceSource = DockerServiceSource | LocalRepoServiceSource;
-export interface ResolvedServiceSources {
-    api: ResolvedServiceSource;
-    frontend: ResolvedServiceSource;
-}
-export interface LocalRepoSourceOptions {
-    apiRepoPath?: LocalRepoOptionValue;
-    webRepoPath?: LocalRepoOptionValue;
-}
-export declare class LocalRepoSourceResolver {
-    private readonly companyhelmRoot;
-    constructor(companyhelmRoot?: string);
-    resolve(options: LocalRepoSourceOptions): ResolvedServiceSources;
-    private resolveService;
-    private assertRepoPathExists;
-}

package/dist/core/local/LocalRepoSourceResolver.js

@@ -1,33 +0,0 @@
-import fs from "node:fs";
-import path from "node:path";
-export class LocalRepoSourceResolver {
-    companyhelmRoot;
-    constructor(companyhelmRoot = process.cwd()) {
-        this.companyhelmRoot = companyhelmRoot;
-    }
-    resolve(options) {
-        return {
-            api: this.resolveService("api", options.apiRepoPath, "../companyhelm-api"),
-            frontend: this.resolveService("frontend", options.webRepoPath, "../companyhelm-web")
-        };
-    }
-    resolveService(service, option, defaultRelativePath) {
-        if (option === undefined) {
-            return {
-                source: "docker"
-            };
-        }
-        const repoPath = path.resolve(this.companyhelmRoot, option === true ? defaultRelativePath : option);
-        this.assertRepoPathExists(service, repoPath);
-        return {
-            source: "local",
-            repoPath
-        };
-    }
-    assertRepoPathExists(service, repoPath) {
-        if (fs.existsSync(repoPath) && fs.statSync(repoPath).isDirectory()) {
-            return;
-        }
-        throw new Error(`Local ${service} repo path does not exist: ${repoPath}`);
-    }
-}

package/dist/core/local/LocalServiceProcessManager.d.ts

@@ -1,18 +0,0 @@
-import type { LocalManagedServiceRuntime } from "../runtime/RuntimeState.js";
-export interface LocalProcessStartInput {
-    serviceName: string;
-    repoPath: string;
-    command: string;
-    args: string[];
-    logPath: string;
-    env?: NodeJS.ProcessEnv;
-}
-export declare class LocalServiceProcessManager {
-    start(input: LocalProcessStartInput): LocalManagedServiceRuntime;
-    isRunning(runtime: LocalManagedServiceRuntime): boolean;
-    stop(runtime: LocalManagedServiceRuntime): Promise<void>;
-    printLogs(runtime: LocalManagedServiceRuntime): void;
-    private kill;
-    private isPidRunning;
-    private waitForExit;
-}

package/dist/core/local/LocalServiceProcessManager.js

@@ -1,83 +0,0 @@
-import fs from "node:fs";
-import { spawn } from "node:child_process";
-import path from "node:path";
-export class LocalServiceProcessManager {
-    start(input) {
-        fs.mkdirSync(path.dirname(input.logPath), { recursive: true });
-        fs.writeFileSync(input.logPath, `\n[companyhelm] starting ${input.serviceName}: ${input.command} ${input.args.join(" ")}\n`, { flag: "a" });
-        const logFd = fs.openSync(input.logPath, "a");
-        const child = spawn(input.command, input.args, {
-            cwd: input.repoPath,
-            env: {
-                ...process.env,
-                ...input.env
-            },
-            stdio: ["ignore", logFd, logFd],
-            detached: true
-        });
-        child.unref();
-        fs.closeSync(logFd);
-        return {
-            source: "local",
-            repoPath: input.repoPath,
-            logPath: input.logPath,
-            pid: child.pid ?? 0
-        };
-    }
-    isRunning(runtime) {
-        return runtime.pid > 0 && this.isPidRunning(runtime.pid);
-    }
-    async stop(runtime) {
-        if (!this.isRunning(runtime)) {
-            return;
-        }
-        this.kill(runtime.pid, "SIGTERM");
-        const exitedAfterSigTerm = await this.waitForExit(runtime.pid, 5000);
-        if (!exitedAfterSigTerm) {
-            this.kill(runtime.pid, "SIGKILL");
-            await this.waitForExit(runtime.pid, 2000);
-        }
-    }
-    printLogs(runtime) {
-        if (!fs.existsSync(runtime.logPath)) {
-            return;
-        }
-        process.stdout.write(fs.readFileSync(runtime.logPath, "utf8"));
-    }
-    kill(pid, signal) {
-        try {
-            process.kill(-pid, signal);
-            return;
-        }
-        catch {
-            // Fall through to direct child kill.
-        }
-        try {
-            process.kill(pid, signal);
-        }
-        catch {
-            // Ignore stale pid files.
-        }
-    }
-    isPidRunning(pid) {
-        try {
-            process.kill(pid, 0);
-            return true;
-        }
-        catch {
-            return false;
-        }
-    }
-    async waitForExit(pid, timeoutMs) {
-        const deadline = Date.now() + timeoutMs;
-        while (Date.now() < deadline) {
-            if (!this.isPidRunning(pid)) {
-                return true;
-            }
-            await new Promise((resolve) => {
-                setTimeout(resolve, 100);
-            });
-        }
-        return !this.isPidRunning(pid);
-    }
-}

package/dist/core/local/WebLocalService.d.ts

@@ -1,23 +0,0 @@
-import { LocalServiceProcessManager } from "./LocalServiceProcessManager.js";
-import { CommandRunner } from "../process/CommandRunner.js";
-import type { LogLevel } from "../../commands/dependencies.js";
-import type { LocalManagedServiceRuntime } from "../runtime/RuntimeState.js";
-export interface WebLocalServiceStartInput {
-    repoPath: string;
-    configPath: string;
-    url: string;
-    uiPort: number;
-    logPath: string;
-    logLevel: LogLevel;
-}
-export declare class WebLocalService {
-    private readonly processManager;
-    private readonly commandRunner;
-    private static readonly SERVICE_NAME;
-    constructor(processManager?: LocalServiceProcessManager, commandRunner?: CommandRunner);
-    start(input: WebLocalServiceStartInput): Promise<LocalManagedServiceRuntime>;
-    private ensureNodeModules;
-    private waitForReadiness;
-    private assertUiPortAvailable;
-    private buildStartupFailureMessage;
-}