@companyhelm/cli 0.1.2 → 0.1.5

package/dist/core/docker/ComposeTemplateRenderer.js

@@ -5,20 +5,63 @@ import { ImageCatalog } from "../runtime/ImageCatalog.js";
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
 export class ComposeTemplateRenderer {
-    render(ports, paths) {
+    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}"`,
+            `      - "${ports.agentCliGrpcPort}:${ports.agentCliGrpcPort}"`,
+            "    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("{{API_IMAGE}}", images.api)
-            .replaceAll("{{FRONTEND_IMAGE}}", images.frontend)
             .replaceAll("{{POSTGRES_IMAGE}}", images.postgres)
+            .replace("{{POSTGRES_PORTS_BLOCK}}", postgresPortsBlock)
+            .replace("{{API_SERVICE_BLOCK}}", apiBlock)
             .replaceAll("{{API_CONFIG_PATH}}", paths.apiConfigPath)
-            .replaceAll("{{FRONTEND_CONFIG_PATH}}", paths.frontendConfigPath)
+            .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));
+            .replaceAll("{{AGENT_CLI_GRPC_PORT}}", String(ports.agentCliGrpcPort))
+            .replace("{{FRONTEND_SERVICE_BLOCK}}", frontendBlock);
     }
 }

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

@@ -1,14 +1,29 @@
+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): Promise<void>;
-    applySeedSql(): Promise<void>;
-    down(): Promise<void>;
+    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,17 +1,20 @@
 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) {
+    async up(state, options = {}) {
         fs.mkdirSync(this.runtimePaths.runnerConfigPath(), { recursive: true });
         fs.writeFileSync(this.runtimePaths.composeFilePath(), this.composeRenderer.render({
             apiHttpPort: state.ports.apiHttp,
@@ -20,8 +23,14 @@ export class DockerStackManager {
             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,
+            includeApi: options.includeApi,
+            includeFrontend: options.includeFrontend,
+            exposePostgresPort: options.exposePostgresPort
         }), "utf8");
         await this.commandRunner.run("docker", [
             "compose",
@@ -31,13 +40,20 @@ export class DockerStackManager {
             "-d"
         ]);
     }
-    async applySeedSql() {
+    async applySeedSql(seedEmail) {
         if (!fs.existsSync(this.runtimePaths.seedFilePath())) {
             return;
         }
         let lastError = null;
-        for (let attempt = 0; attempt < 20; attempt += 1) {
+        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",
@@ -57,23 +73,69 @@ export class DockerStackManager {
             }
             catch (error) {
                 lastError = error;
-                await new Promise((resolve) => {
-                    setTimeout(resolve, 1000);
-                });
+                await this.waitForNextBootstrapAttempt();
             }
         }
         throw lastError ?? new Error("Failed to apply seed SQL.");
     }
-    async down() {
+    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;
         }
-        await this.commandRunner.run("docker", [
+        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) {

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

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

@@ -0,0 +1,65 @@
+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

@@ -0,0 +1,24 @@
+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

@@ -0,0 +1,33 @@
+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

@@ -0,0 +1,18 @@
+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

@@ -0,0 +1,83 @@
+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

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

package/dist/core/local/WebLocalService.js

@@ -0,0 +1,101 @@
+import fs from "node:fs";
+import net from "node:net";
+import { LocalServiceProcessManager } from "./LocalServiceProcessManager.js";
+import { CommandRunner } from "../process/CommandRunner.js";
+export class WebLocalService {
+    processManager;
+    commandRunner;
+    static SERVICE_NAME = "companyhelm-web";
+    constructor(processManager = new LocalServiceProcessManager(), commandRunner = new CommandRunner()) {
+        this.processManager = processManager;
+        this.commandRunner = commandRunner;
+    }
+    async start(input) {
+        await this.assertUiPortAvailable(input.uiPort);
+        await this.ensureNodeModules(input.repoPath);
+        await this.commandRunner.run("npm", ["run", "config:generate", "--", "--config-path", input.configPath], input.repoPath, {
+            APP_ENV: "local"
+        });
+        const runtime = this.processManager.start({
+            serviceName: WebLocalService.SERVICE_NAME,
+            repoPath: input.repoPath,
+            command: process.execPath,
+            args: [
+                "./node_modules/vite/bin/vite.js",
+                "dev",
+                "--host",
+                "0.0.0.0",
+                "--port",
+                String(input.uiPort)
+            ],
+            logPath: input.logPath,
+            env: {
+                APP_ENV: "local",
+                COMPANYHELM_LOG_LEVEL: input.logLevel,
+                npm_config_loglevel: input.logLevel
+            }
+        });
+        await this.waitForReadiness(input.url, runtime);
+        return runtime;
+    }
+    async ensureNodeModules(repoPath) {
+        if (fs.existsSync(`${repoPath}/node_modules`)) {
+            return;
+        }
+        await this.commandRunner.run("npm", ["install"], repoPath);
+    }
+    async waitForReadiness(url, runtime) {
+        const deadline = Date.now() + 60_000;
+        while (Date.now() < deadline) {
+            if (!this.processManager.isRunning(runtime)) {
+                throw new Error(this.buildStartupFailureMessage(runtime, `${WebLocalService.SERVICE_NAME} exited before becoming ready.`));
+            }
+            try {
+                const response = await fetch(url);
+                if (response.ok) {
+                    return;
+                }
+            }
+            catch {
+                // Retry until the deadline.
+            }
+            await new Promise((resolve) => {
+                setTimeout(resolve, 1000);
+            });
+        }
+        throw new Error(`companyhelm-web did not become ready: ${url}`);
+    }
+    async assertUiPortAvailable(port) {
+        await new Promise((resolve, reject) => {
+            const server = net.createServer();
+            server.once("error", (error) => {
+                if (error.code === "EADDRINUSE") {
+                    reject(new Error(`companyhelm-web cannot start because port ${port} is already in use.`));
+                    return;
+                }
+                reject(new Error(`companyhelm-web cannot verify port ${port}: ${error.message}`));
+            });
+            server.once("listening", () => {
+                server.close((closeError) => {
+                    if (closeError) {
+                        reject(closeError);
+                        return;
+                    }
+                    resolve();
+                });
+            });
+            server.listen(port, "0.0.0.0");
+        });
+    }
+    buildStartupFailureMessage(runtime, summary) {
+        if (!fs.existsSync(runtime.logPath)) {
+            return summary;
+        }
+        const startupLog = fs.readFileSync(runtime.logPath, "utf8").trim();
+        if (!startupLog) {
+            return summary;
+        }
+        const tail = startupLog.split(/\r?\n/).slice(-20).join("\n");
+        return `${summary}\nStartup log:\n${tail}`;
+    }
+}

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

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

package/dist/core/process/CommandRunner.js

@@ -1,9 +1,13 @@
 import { spawn } from "node:child_process";
 export class CommandRunner {
-    run(command, args, cwd) {
+    run(command, args, cwd, env) {
         return new Promise((resolve, reject) => {
             const child = spawn(command, args, {
                 cwd,
+                env: {
+                    ...process.env,
+                    ...env
+                },
                 stdio: "inherit"
             });
             child.on("error", reject);
@@ -16,10 +20,14 @@ export class CommandRunner {
             });
         });
     }
-    capture(command, args, cwd) {
+    capture(command, args, cwd, env) {
         return new Promise((resolve, reject) => {
             const child = spawn(command, args, {
                 cwd,
+                env: {
+                    ...process.env,
+                    ...env
+                },
                 stdio: ["ignore", "pipe", "pipe"]
             });
             let stdout = "";

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

@@ -1,8 +1,11 @@
+import type { LogLevel } from "../../commands/dependencies.js";
 export interface RunnerStartInput {
     serverUrl: string;
     agentApiUrl: string;
     logPath: string;
     secret: string;
+    logLevel?: LogLevel;
+    useHostDockerRuntime?: boolean;
 }
 export interface RunnerStartCommand {
     command: string;
@@ -11,7 +14,10 @@ export interface RunnerStartCommand {
 export declare class RunnerSupervisor {
     private readonly configPath;
     constructor(configPath: string);
+    buildUseHostAuthArgs(): RunnerStartCommand;
     buildStartArgs(input: RunnerStartInput): RunnerStartCommand;
     buildStopArgs(): RunnerStartCommand;
+    buildStatusArgs(): RunnerStartCommand;
     private resolveRunnerCliPath;
+    private resolveHostDockerPath;
 }