@companyhelm/cli 0.0.11 → 0.1.2

package/dist/core/docker/DockerStackManager.js

@@ -0,0 +1,102 @@
+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;
+    runtimePaths;
+    constructor(root, commandRunner = new CommandRunner(), composeRenderer = new ComposeTemplateRenderer()) {
+        this.commandRunner = commandRunner;
+        this.composeRenderer = composeRenderer;
+        this.runtimePaths = new RuntimePaths(root);
+    }
+    async up(state) {
+        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(),
+            frontendConfigPath: this.runtimePaths.frontendConfigPath(),
+            seedFilePath: this.runtimePaths.seedFilePath()
+        }), "utf8");
+        await this.commandRunner.run("docker", [
+            "compose",
+            "-f",
+            this.runtimePaths.composeFilePath(),
+            "up",
+            "-d"
+        ]);
+    }
+    async applySeedSql() {
+        if (!fs.existsSync(this.runtimePaths.seedFilePath())) {
+            return;
+        }
+        let lastError = null;
+        for (let attempt = 0; attempt < 20; attempt += 1) {
+            try {
+                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 new Promise((resolve) => {
+                    setTimeout(resolve, 1000);
+                });
+            }
+        }
+        throw lastError ?? new Error("Failed to apply seed SQL.");
+    }
+    async down() {
+        if (!fs.existsSync(this.runtimePaths.composeFilePath())) {
+            return;
+        }
+        await this.commandRunner.run("docker", [
+            "compose",
+            "-f",
+            this.runtimePaths.composeFilePath(),
+            "down",
+            "--remove-orphans"
+        ]);
+    }
+    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,17 @@
+export interface RunnerStartInput {
+    serverUrl: string;
+    agentApiUrl: string;
+    logPath: string;
+    secret: string;
+}
+export interface RunnerStartCommand {
+    command: string;
+    args: string[];
+}
+export declare class RunnerSupervisor {
+    private readonly configPath;
+    constructor(configPath: string);
+    buildStartArgs(input: RunnerStartInput): RunnerStartCommand;
+    buildStopArgs(): RunnerStartCommand;
+    private resolveRunnerCliPath;
+}

package/dist/core/runner/RunnerSupervisor.js

@@ -0,0 +1,45 @@
+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;
+    }
+    buildStartArgs(input) {
+        const runnerCliPath = this.resolveRunnerCliPath();
+        return {
+            command: process.execPath,
+            args: [
+                runnerCliPath,
+                "--config-path",
+                this.configPath,
+                "runner",
+                "start",
+                "--daemon",
+                "--server-url",
+                input.serverUrl,
+                "--agent-api-url",
+                input.agentApiUrl,
+                "--log-path",
+                input.logPath,
+                "--secret",
+                input.secret
+            ]
+        };
+    }
+    buildStopArgs() {
+        const runnerCliPath = this.resolveRunnerCliPath();
+        return {
+            command: process.execPath,
+            args: [runnerCliPath, "--config-path", this.configPath, "runner", "stop"]
+        };
+    }
+    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,9 @@
+export class ImageCatalog {
+    resolve() {
+        return {
+            api: process.env.COMPANYHELM_API_IMAGE || "companyhelm-api:latest",
+            frontend: process.env.COMPANYHELM_WEB_IMAGE || "companyhelm-web:latest",
+            postgres: process.env.COMPANYHELM_POSTGRES_IMAGE || "postgres:16-alpine"
+        };
+    }
+}

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/RuntimePaths.d.ts

@@ -0,0 +1,12 @@
+export declare class RuntimePaths {
+    private readonly root;
+    constructor(root: string);
+    stateFilePath(): string;
+    composeFilePath(): string;
+    apiConfigPath(): string;
+    frontendConfigPath(): string;
+    seedFilePath(): string;
+    runnerConfigPath(): string;
+    runnerStateDbPath(): string;
+    runnerLogPath(): string;
+}

package/dist/core/runtime/RuntimePaths.js

@@ -0,0 +1,31 @@
+import path from "node:path";
+export class RuntimePaths {
+    root;
+    constructor(root) {
+        this.root = root;
+    }
+    stateFilePath() {
+        return path.join(this.root, "state.json");
+    }
+    composeFilePath() {
+        return path.join(this.root, "docker-compose.yaml");
+    }
+    apiConfigPath() {
+        return path.join(this.root, "api-config.yaml");
+    }
+    frontendConfigPath() {
+        return path.join(this.root, "frontend-config.yaml");
+    }
+    seedFilePath() {
+        return path.join(this.root, "seed.sql");
+    }
+    runnerConfigPath() {
+        return path.join(this.root, "runner");
+    }
+    runnerStateDbPath() {
+        return path.join(this.runnerConfigPath(), "state.db");
+    }
+    runnerLogPath() {
+        return path.join(this.runnerConfigPath(), "daemon.log");
+    }
+}

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

@@ -0,0 +1,24 @@
+export interface RuntimePorts {
+    apiHttp: number;
+    ui: number;
+    runnerGrpc: number;
+    agentCliGrpc: number;
+}
+export interface RuntimeState {
+    version: 1;
+    company: {
+        id: string;
+        name: string;
+    };
+    auth: {
+        username: "admin";
+        password: string;
+        jwtPrivateKeyPem: string;
+        jwtPublicKeyPem: string;
+    };
+    runner: {
+        name: string;
+        secret: string;
+    };
+    ports: RuntimePorts;
+}

package/dist/core/runtime/RuntimeState.js

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,9 @@
+import type { RuntimeState } from "./RuntimeState.js";
+export declare class RuntimeStateStore {
+    private readonly root;
+    private readonly runtimePaths;
+    constructor(root: string);
+    initialize(): RuntimeState;
+    load(): RuntimeState | null;
+    private save;
+}

package/dist/core/runtime/RuntimeStateStore.js

@@ -0,0 +1,52 @@
+import fs from "node:fs";
+import { PortAllocator } from "./PortAllocator.js";
+import { RuntimePaths } from "./RuntimePaths.js";
+import { createPemKeyPair, randomCompanyId, randomSecret } from "./Secrets.js";
+export class RuntimeStateStore {
+    root;
+    runtimePaths;
+    constructor(root) {
+        this.root = root;
+        this.runtimePaths = new RuntimePaths(root);
+    }
+    initialize() {
+        const existingState = this.load();
+        if (existingState) {
+            return existingState;
+        }
+        fs.mkdirSync(this.root, { recursive: true });
+        const authKeys = createPemKeyPair();
+        const state = {
+            version: 1,
+            company: {
+                id: randomCompanyId(),
+                name: "Local CompanyHelm"
+            },
+            auth: {
+                username: "admin",
+                password: randomSecret(),
+                jwtPrivateKeyPem: authKeys.privateKeyPem,
+                jwtPublicKeyPem: authKeys.publicKeyPem
+            },
+            runner: {
+                name: "local-runner",
+                secret: randomSecret()
+            },
+            ports: new PortAllocator().allocate()
+        };
+        this.save(state);
+        return state;
+    }
+    load() {
+        if (!fs.existsSync(this.runtimePaths.stateFilePath())) {
+            return null;
+        }
+        return JSON.parse(fs.readFileSync(this.runtimePaths.stateFilePath(), "utf8"));
+    }
+    save(state) {
+        fs.writeFileSync(this.runtimePaths.stateFilePath(), `${JSON.stringify(state, null, 2)}\n`, {
+            encoding: "utf8",
+            mode: 0o600
+        });
+    }
+}

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

@@ -0,0 +1,10 @@
+export declare function randomSecret(length?: number): string;
+export declare function randomCompanyId(): string;
+export declare function createPasswordHash(password: string): {
+    passwordSalt: string;
+    passwordHash: string;
+};
+export declare function createPemKeyPair(): {
+    privateKeyPem: string;
+    publicKeyPem: string;
+};

package/dist/core/runtime/Secrets.js

@@ -0,0 +1,26 @@
+import { generateKeyPairSync, randomBytes, randomUUID, scryptSync } from "node:crypto";
+export function randomSecret(length = 24) {
+    return randomBytes(length).toString("base64url");
+}
+export function randomCompanyId() {
+    return randomUUID();
+}
+export function createPasswordHash(password) {
+    const passwordSalt = randomBytes(16).toString("hex");
+    const passwordHash = scryptSync(password, passwordSalt, 64).toString("hex");
+    return {
+        passwordSalt,
+        passwordHash
+    };
+}
+export function createPemKeyPair() {
+    const { privateKey, publicKey } = generateKeyPairSync("rsa", {
+        modulusLength: 2048,
+        privateKeyEncoding: { format: "pem", type: "pkcs1" },
+        publicKeyEncoding: { format: "pem", type: "pkcs1" }
+    });
+    return {
+        privateKeyPem: privateKey,
+        publicKeyPem: publicKey
+    };
+}

package/dist/core/status/StatusService.d.ts

@@ -0,0 +1,12 @@
+export type ManagedServiceStatus = "running" | "stopped";
+export interface StatusSnapshot {
+    postgres: ManagedServiceStatus;
+    api: ManagedServiceStatus;
+    frontend: ManagedServiceStatus;
+    runner: ManagedServiceStatus;
+}
+export declare class StatusService {
+    private readonly listRunningServices;
+    constructor(listRunningServices: () => Promise<string>);
+    read(): Promise<StatusSnapshot>;
+}

package/dist/core/status/StatusService.js

@@ -0,0 +1,18 @@
+export class StatusService {
+    listRunningServices;
+    constructor(listRunningServices) {
+        this.listRunningServices = listRunningServices;
+    }
+    async read() {
+        const running = new Set((await this.listRunningServices())
+            .split("\n")
+            .map((service) => service.trim())
+            .filter(Boolean));
+        return {
+            postgres: running.has("postgres") ? "running" : "stopped",
+            api: running.has("api") ? "running" : "stopped",
+            frontend: running.has("frontend") ? "running" : "stopped",
+            runner: running.has("runner") ? "running" : "stopped"
+        };
+    }
+}

package/dist/core/ui/TerminalRenderer.d.ts

@@ -0,0 +1,7 @@
+export declare class TerminalRenderer {
+    private readonly useColor;
+    constructor(useColor?: boolean);
+    renderBanner(): string;
+    success(message: string): string;
+    private colorize;
+}

package/dist/core/ui/TerminalRenderer.js

@@ -0,0 +1,23 @@
+import chalk from "chalk";
+import figlet from "figlet";
+export class TerminalRenderer {
+    useColor;
+    constructor(useColor = true) {
+        this.useColor = useColor;
+    }
+    renderBanner() {
+        const banner = figlet.textSync("COMPANYHELM", {
+            horizontalLayout: "fitted"
+        });
+        return this.colorize(`COMPANYHELM\n${banner}`, "cyan");
+    }
+    success(message) {
+        return `${this.colorize("[ok]", "green")} ${message}`;
+    }
+    colorize(text, color) {
+        if (!this.useColor) {
+            return text;
+        }
+        return chalk[color](text);
+    }
+}

package/dist/templates/docker-compose.yaml.tpl

@@ -0,0 +1,48 @@
+services:
+  postgres:
+    image: {{POSTGRES_IMAGE}}
+    environment:
+      POSTGRES_USER: postgres
+      POSTGRES_PASSWORD: postgres
+      POSTGRES_DB: companyhelm
+    volumes:
+      - companyhelm_postgres_data:/var/lib/postgresql/data
+      - "{{SEED_FILE_PATH}}:/run/companyhelm/seed.sql:ro"
+    networks:
+      - companyhelm
+
+  api:
+    image: {{API_IMAGE}}
+    depends_on:
+      - postgres
+    environment:
+      COMPANYHELM_CONFIG_PATH: /run/companyhelm/config.yaml
+    ports:
+      - "{{API_HTTP_PORT}}:4000"
+      - "{{RUNNER_GRPC_PORT}}:{{RUNNER_GRPC_PORT}}"
+      - "{{AGENT_CLI_GRPC_PORT}}:{{AGENT_CLI_GRPC_PORT}}"
+    volumes:
+      - "{{API_CONFIG_PATH}}:/run/companyhelm/config.yaml:ro"
+    networks:
+      - companyhelm
+
+  frontend:
+    image: {{FRONTEND_IMAGE}}
+    depends_on:
+      - api
+    environment:
+      COMPANYHELM_CONFIG_PATH: /run/companyhelm/config.yaml
+      PORT: "{{UI_PORT}}"
+    ports:
+      - "{{UI_PORT}}:{{UI_PORT}}"
+    volumes:
+      - "{{FRONTEND_CONFIG_PATH}}:/run/companyhelm/config.yaml:ro"
+    networks:
+      - companyhelm
+
+networks:
+  companyhelm:
+    driver: bridge
+
+volumes:
+  companyhelm_postgres_data:

package/dist/templates/seed.sql.tpl

@@ -0,0 +1,57 @@
+BEGIN;
+
+INSERT INTO companies (id, name)
+VALUES ('{{COMPANY_ID}}', '{{COMPANY_NAME}}')
+ON CONFLICT (id) DO UPDATE
+SET name = EXCLUDED.name;
+
+INSERT INTO users (id, first_name, last_name, email, auth_provider, created_at, updated_at)
+VALUES (
+  '{{USER_ID}}',
+  '{{USER_FIRST_NAME}}',
+  NULL,
+  '{{USER_EMAIL}}',
+  'companyhelm',
+  NOW(),
+  NOW()
+)
+ON CONFLICT (email) DO UPDATE
+SET first_name = EXCLUDED.first_name,
+    auth_provider = EXCLUDED.auth_provider,
+    updated_at = NOW();
+
+INSERT INTO user_auths (id, user_id, email, password_salt, password_hash, created_at, updated_at)
+VALUES (
+  '{{USER_AUTH_ID}}',
+  '{{USER_ID}}',
+  '{{USER_EMAIL}}',
+  '{{PASSWORD_SALT}}',
+  '{{PASSWORD_HASH}}',
+  NOW(),
+  NOW()
+)
+ON CONFLICT (user_id) DO UPDATE
+SET email = EXCLUDED.email,
+    password_salt = EXCLUDED.password_salt,
+    password_hash = EXCLUDED.password_hash,
+    updated_at = NOW();
+
+INSERT INTO company_members (company_id, user_id)
+VALUES ('{{COMPANY_ID}}', '{{USER_ID}}')
+ON CONFLICT (company_id, user_id) DO NOTHING;
+
+INSERT INTO agent_runners (id, company_id, secret_hash, status, name)
+VALUES (
+  '{{RUNNER_ID}}',
+  '{{COMPANY_ID}}',
+  '{{RUNNER_SECRET_HASH}}',
+  'ready',
+  '{{RUNNER_NAME}}'
+)
+ON CONFLICT (id) DO UPDATE
+SET company_id = EXCLUDED.company_id,
+    secret_hash = EXCLUDED.secret_hash,
+    status = EXCLUDED.status,
+    name = EXCLUDED.name;
+
+COMMIT;