@companyhelm/cli 0.0.12 → 0.1.4

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

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

@@ -0,0 +1,161 @@
+import fs from "node:fs";
+import { CommandRunner } from "../process/CommandRunner.js";
+import { ProjectPaths } from "../runtime/ProjectPaths.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: new ProjectPaths(process.cwd()).apiEnvPath(),
+            frontendConfigPath: this.runtimePaths.frontendConfigPath(),
+            seedFilePath: this.runtimePaths.seedFilePath()
+        }, {
+            frontendLogLevel: options.frontendLogLevel
+        }), "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/logs/LogsService.d.ts

@@ -0,0 +1,5 @@
+export declare class LogsService {
+    private readonly streamServiceLogs;
+    constructor(streamServiceLogs: (service: "postgres" | "api" | "frontend" | "runner") => Promise<void>);
+    stream(service: string): Promise<void>;
+}

package/dist/core/logs/LogsService.js

@@ -0,0 +1,13 @@
+const MANAGED_SERVICES = new Set(["postgres", "api", "frontend", "runner"]);
+export class LogsService {
+    streamServiceLogs;
+    constructor(streamServiceLogs) {
+        this.streamServiceLogs = streamServiceLogs;
+    }
+    async stream(service) {
+        if (!MANAGED_SERVICES.has(service)) {
+            throw new Error(`Unknown service '${service}'. Expected one of: ${Array.from(MANAGED_SERVICES).join(", ")}`);
+        }
+        await this.streamServiceLogs(service);
+    }
+}

package/dist/core/process/CommandRunner.d.ts

@@ -0,0 +1,4 @@
+export declare class CommandRunner {
+    run(command: string, args: string[], cwd?: string): Promise<void>;
+    capture(command: string, args: string[], cwd?: string): Promise<string>;
+}

package/dist/core/process/CommandRunner.js

@@ -0,0 +1,43 @@
+import { spawn } from "node:child_process";
+export class CommandRunner {
+    run(command, args, cwd) {
+        return new Promise((resolve, reject) => {
+            const child = spawn(command, args, {
+                cwd,
+                stdio: "inherit"
+            });
+            child.on("error", reject);
+            child.on("exit", (code) => {
+                if (code === 0) {
+                    resolve();
+                    return;
+                }
+                reject(new Error(`${command} exited with code ${code ?? "unknown"}`));
+            });
+        });
+    }
+    capture(command, args, cwd) {
+        return new Promise((resolve, reject) => {
+            const child = spawn(command, args, {
+                cwd,
+                stdio: ["ignore", "pipe", "pipe"]
+            });
+            let stdout = "";
+            let stderr = "";
+            child.stdout.on("data", (chunk) => {
+                stdout += String(chunk);
+            });
+            child.stderr.on("data", (chunk) => {
+                stderr += String(chunk);
+            });
+            child.on("error", reject);
+            child.on("exit", (code) => {
+                if (code === 0) {
+                    resolve(stdout);
+                    return;
+                }
+                reject(new Error(stderr || `${command} exited with code ${code ?? "unknown"}`));
+            });
+        });
+    }
+}

package/dist/core/runner/RunnerSupervisor.d.ts

@@ -0,0 +1,21 @@
+import type { LogLevel } from "../../commands/dependencies.js";
+export interface RunnerStartInput {
+    serverUrl: string;
+    agentApiUrl: string;
+    logPath: string;
+    secret: string;
+    logLevel?: LogLevel;
+}
+export interface RunnerStartCommand {
+    command: string;
+    args: string[];
+}
+export declare class RunnerSupervisor {
+    private readonly configPath;
+    constructor(configPath: string);
+    buildUseHostAuthArgs(): RunnerStartCommand;
+    buildStartArgs(input: RunnerStartInput): RunnerStartCommand;
+    buildStopArgs(): RunnerStartCommand;
+    buildStatusArgs(): RunnerStartCommand;
+    private resolveRunnerCliPath;
+}

package/dist/core/runner/RunnerSupervisor.js

@@ -0,0 +1,61 @@
+import path from "node:path";
+import { createRequire } from "node:module";
+const require = createRequire(import.meta.url);
+export class RunnerSupervisor {
+    configPath;
+    constructor(configPath) {
+        this.configPath = configPath;
+    }
+    buildUseHostAuthArgs() {
+        const runnerCliPath = this.resolveRunnerCliPath();
+        return {
+            command: process.execPath,
+            args: [runnerCliPath, "--config-path", this.configPath, "sdk", "codex", "use-host-auth"]
+        };
+    }
+    buildStartArgs(input) {
+        const runnerCliPath = this.resolveRunnerCliPath();
+        const logLevel = (input.logLevel ?? "info").toUpperCase();
+        return {
+            command: process.execPath,
+            args: [
+                runnerCliPath,
+                "--config-path",
+                this.configPath,
+                "start",
+                "--daemon",
+                "--server-url",
+                input.serverUrl,
+                "--agent-api-url",
+                input.agentApiUrl,
+                "--log-path",
+                input.logPath,
+                "--secret",
+                input.secret,
+                "--log-level",
+                logLevel
+            ]
+        };
+    }
+    buildStopArgs() {
+        const runnerCliPath = this.resolveRunnerCliPath();
+        return {
+            command: process.execPath,
+            args: [runnerCliPath, "--config-path", this.configPath, "stop"]
+        };
+    }
+    buildStatusArgs() {
+        const runnerCliPath = this.resolveRunnerCliPath();
+        return {
+            command: process.execPath,
+            args: [runnerCliPath, "--config-path", this.configPath, "status"]
+        };
+    }
+    resolveRunnerCliPath() {
+        if (process.env.COMPANYHELM_RUNNER_CLI_PATH) {
+            return process.env.COMPANYHELM_RUNNER_CLI_PATH;
+        }
+        const packageJsonPath = require.resolve("@companyhelm/runner/package.json");
+        return path.resolve(path.dirname(packageJsonPath), "dist/cli.js");
+    }
+}

package/dist/core/runtime/ImageCatalog.d.ts

@@ -0,0 +1,8 @@
+export interface RuntimeImages {
+    api: string;
+    frontend: string;
+    postgres: string;
+}
+export declare class ImageCatalog {
+    resolve(): RuntimeImages;
+}

package/dist/core/runtime/ImageCatalog.js

@@ -0,0 +1,12 @@
+import { LocalConfigStore } from "./LocalConfigStore.js";
+import { defaultManagedImageReference } from "./ManagedImages.js";
+export class ImageCatalog {
+    resolve() {
+        const configuredImages = new LocalConfigStore().load().images;
+        return {
+            api: configuredImages.api || process.env.COMPANYHELM_API_IMAGE || defaultManagedImageReference("api"),
+            frontend: configuredImages.frontend || process.env.COMPANYHELM_WEB_IMAGE || defaultManagedImageReference("frontend"),
+            postgres: process.env.COMPANYHELM_POSTGRES_IMAGE || "postgres:16-alpine"
+        };
+    }
+}

package/dist/core/runtime/LocalConfigStore.d.ts

@@ -0,0 +1,16 @@
+import type { ManagedImageService } from "./ManagedImages.js";
+export interface LocalConfig {
+    images: Partial<Record<ManagedImageService, string>>;
+}
+export declare class LocalConfigStore {
+    private readonly root;
+    constructor(root?: string);
+    configPath(): string;
+    load(): LocalConfig;
+    setImage(service: ManagedImageService, image: string): {
+        configPath: string;
+        image: string;
+    };
+    save(config: LocalConfig): void;
+    private parse;
+}

package/dist/core/runtime/LocalConfigStore.js

@@ -0,0 +1,59 @@
+import fs from "node:fs";
+import path from "node:path";
+export class LocalConfigStore {
+    root;
+    constructor(root = process.cwd()) {
+        this.root = root;
+    }
+    configPath() {
+        return path.join(this.root, "config.yaml");
+    }
+    load() {
+        const configPath = this.configPath();
+        if (!fs.existsSync(configPath)) {
+            return { images: {} };
+        }
+        return this.parse(fs.readFileSync(configPath, "utf8"));
+    }
+    setImage(service, image) {
+        const nextConfig = this.load();
+        nextConfig.images[service] = image;
+        this.save(nextConfig);
+        return { configPath: this.configPath(), image };
+    }
+    save(config) {
+        const lines = ["images:"];
+        if (config.images.api) {
+            lines.push(`  api: ${config.images.api}`);
+        }
+        if (config.images.frontend) {
+            lines.push(`  frontend: ${config.images.frontend}`);
+        }
+        fs.writeFileSync(this.configPath(), `${lines.join("\n")}\n`, "utf8");
+    }
+    parse(content) {
+        const images = {};
+        let inImagesSection = false;
+        for (const rawLine of content.split(/\r?\n/)) {
+            const line = rawLine.trimEnd();
+            if (line.trim().length === 0 || line.trimStart().startsWith("#")) {
+                continue;
+            }
+            if (line === "images:") {
+                inImagesSection = true;
+                continue;
+            }
+            if (inImagesSection && /^[^\s]/.test(line)) {
+                inImagesSection = false;
+            }
+            if (!inImagesSection) {
+                continue;
+            }
+            const match = line.match(/^  (api|frontend):\s*(.+)$/);
+            if (match) {
+                images[match[1]] = match[2];
+            }
+        }
+        return { images };
+    }
+}

package/dist/core/runtime/ManagedImages.d.ts

@@ -0,0 +1,10 @@
+export declare const MANAGED_IMAGE_SERVICES: readonly ["api", "frontend"];
+export type ManagedImageService = (typeof MANAGED_IMAGE_SERVICES)[number];
+export interface ManagedImageDefinition {
+    imageUri: string;
+    repositoryPath: string;
+}
+export declare function requireManagedImageService(value: string): ManagedImageService;
+export declare function getManagedImageDefinition(service: ManagedImageService): ManagedImageDefinition;
+export declare function buildManagedImageReference(service: ManagedImageService, tag: string): string;
+export declare function defaultManagedImageReference(service: ManagedImageService): string;

package/dist/core/runtime/ManagedImages.js

@@ -0,0 +1,27 @@
+export const MANAGED_IMAGE_SERVICES = ["api", "frontend"];
+const MANAGED_IMAGE_DEFINITIONS = {
+    api: {
+        imageUri: "public.ecr.aws/x6n0f2k4/companyhelm-api",
+        repositoryPath: "x6n0f2k4/companyhelm-api"
+    },
+    frontend: {
+        imageUri: "public.ecr.aws/x6n0f2k4/companyhelm-web",
+        repositoryPath: "x6n0f2k4/companyhelm-web"
+    }
+};
+export function requireManagedImageService(value) {
+    const normalized = value.trim().toLowerCase();
+    if (normalized === "api" || normalized === "frontend") {
+        return normalized;
+    }
+    throw new Error(`Unsupported image service "${value}". Expected one of: api, frontend.`);
+}
+export function getManagedImageDefinition(service) {
+    return MANAGED_IMAGE_DEFINITIONS[service];
+}
+export function buildManagedImageReference(service, tag) {
+    return `${MANAGED_IMAGE_DEFINITIONS[service].imageUri}:${tag}`;
+}
+export function defaultManagedImageReference(service) {
+    return buildManagedImageReference(service, "latest");
+}

package/dist/core/runtime/PortAllocator.d.ts

@@ -0,0 +1,9 @@
+import type { RuntimePorts } from "./RuntimeState.js";
+export declare class PortAllocator {
+    private readonly apiHttpPort;
+    private readonly uiPort;
+    private readonly runnerGrpcPort;
+    private readonly agentCliGrpcPort;
+    constructor(apiHttpPort?: number, uiPort?: number, runnerGrpcPort?: number, agentCliGrpcPort?: number);
+    allocate(): RuntimePorts;
+}

package/dist/core/runtime/PortAllocator.js

@@ -0,0 +1,20 @@
+export class PortAllocator {
+    apiHttpPort;
+    uiPort;
+    runnerGrpcPort;
+    agentCliGrpcPort;
+    constructor(apiHttpPort = 4000, uiPort = 4173, runnerGrpcPort = 50051, agentCliGrpcPort = 50052) {
+        this.apiHttpPort = apiHttpPort;
+        this.uiPort = uiPort;
+        this.runnerGrpcPort = runnerGrpcPort;
+        this.agentCliGrpcPort = agentCliGrpcPort;
+    }
+    allocate() {
+        return {
+            apiHttp: this.apiHttpPort,
+            ui: this.uiPort,
+            runnerGrpc: this.runnerGrpcPort,
+            agentCliGrpc: this.agentCliGrpcPort
+        };
+    }
+}

package/dist/core/runtime/ProjectPaths.d.ts

@@ -0,0 +1,7 @@
+export declare class ProjectPaths {
+    private readonly root;
+    constructor(root?: string);
+    companyhelmRootPath(): string;
+    apiDirectoryPath(): string;
+    apiEnvPath(): string;
+}

package/dist/core/runtime/ProjectPaths.js

@@ -0,0 +1,16 @@
+import path from "node:path";
+export class ProjectPaths {
+    root;
+    constructor(root = process.cwd()) {
+        this.root = root;
+    }
+    companyhelmRootPath() {
+        return path.join(this.root, ".companyhelm");
+    }
+    apiDirectoryPath() {
+        return path.join(this.companyhelmRootPath(), "api");
+    }
+    apiEnvPath() {
+        return path.join(this.apiDirectoryPath(), ".env");
+    }
+}

package/dist/core/runtime/PublicImageTagRegistry.d.ts

@@ -0,0 +1,16 @@
+import { type ManagedImageService } from "./ManagedImages.js";
+interface PublicRegistryImageTag {
+    tag: string;
+    createdAt?: string;
+}
+export declare class PublicImageTagRegistry {
+    listAvailableTags(service: ManagedImageService, limit?: number): Promise<PublicRegistryImageTag[]>;
+    buildImageReference(service: ManagedImageService, tag: string): string;
+    private fetchToken;
+    private fetchCreatedAt;
+    private selectManifestDigest;
+    private fetchJson;
+    private parseRetryAfterMs;
+    private sleep;
+}
+export {};