@companyhelm/cli 0.1.2 → 0.1.4

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,11 @@ 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
         }), "utf8");
         await this.commandRunner.run("docker", [
             "compose",
@@ -31,13 +37,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 +70,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/runner/RunnerSupervisor.d.ts

@@ -1,8 +1,10 @@
+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;
@@ -11,7 +13,9 @@ 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;
 }

package/dist/core/runner/RunnerSupervisor.js

@@ -6,15 +6,22 @@ export class RunnerSupervisor {
     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,
-                "runner",
                 "start",
                 "--daemon",
                 "--server-url",
@@ -24,7 +31,9 @@ export class RunnerSupervisor {
                 "--log-path",
                 input.logPath,
                 "--secret",
-                input.secret
+                input.secret,
+                "--log-level",
+                logLevel
             ]
         };
     }
@@ -32,7 +41,14 @@ export class RunnerSupervisor {
         const runnerCliPath = this.resolveRunnerCliPath();
         return {
             command: process.execPath,
-            args: [runnerCliPath, "--config-path", this.configPath, "runner", "stop"]
+            args: [runnerCliPath, "--config-path", this.configPath, "stop"]
+        };
+    }
+    buildStatusArgs() {
+        const runnerCliPath = this.resolveRunnerCliPath();
+        return {
+            command: process.execPath,
+            args: [runnerCliPath, "--config-path", this.configPath, "status"]
         };
     }
     resolveRunnerCliPath() {

package/dist/core/runtime/ImageCatalog.js

@@ -1,8 +1,11 @@
+import { LocalConfigStore } from "./LocalConfigStore.js";
+import { defaultManagedImageReference } from "./ManagedImages.js";
 export class ImageCatalog {
     resolve() {
+        const configuredImages = new LocalConfigStore().load().images;
         return {
-            api: process.env.COMPANYHELM_API_IMAGE || "companyhelm-api:latest",
-            frontend: process.env.COMPANYHELM_WEB_IMAGE || "companyhelm-web:latest",
+            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/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 {};

package/dist/core/runtime/PublicImageTagRegistry.js

@@ -0,0 +1,148 @@
+import { buildManagedImageReference, getManagedImageDefinition } from "./ManagedImages.js";
+const RETRYABLE_STATUS_CODES = new Set([429, 500, 502, 503, 504]);
+const MAX_FETCH_ATTEMPTS = 3;
+const DEFAULT_RETRY_DELAY_MS = 250;
+class PublicRegistryRequestError extends Error {
+    status;
+    retryAfterMs;
+    constructor(url, status, retryAfterMs) {
+        super(`Public registry returned ${status} for ${url}.`);
+        this.status = status;
+        this.retryAfterMs = retryAfterMs;
+    }
+}
+export class PublicImageTagRegistry {
+    async listAvailableTags(service, limit = 20) {
+        if (!Number.isInteger(limit) || limit < 1) {
+            throw new Error("Image tag limit must be a positive integer.");
+        }
+        const { repositoryPath } = getManagedImageDefinition(service);
+        const token = await this.fetchToken(repositoryPath);
+        const response = await fetch(`https://public.ecr.aws/v2/${repositoryPath}/tags/list`, {
+            headers: {
+                Authorization: `Bearer ${token}`
+            }
+        });
+        if (!response.ok) {
+            throw new Error(`Public registry returned ${response.status} for ${service} tags.`);
+        }
+        const payload = (await response.json());
+        if (payload.errors?.length) {
+            throw new Error(payload.errors[0]?.message || `Unable to load ${service} image tags.`);
+        }
+        const uniqueTags = [...new Set(payload.tags ?? [])].map((tag, position) => ({ tag, position }));
+        const createdAtByDigest = new Map();
+        const tagsWithMetadata = [];
+        for (const { tag, position } of uniqueTags) {
+            tagsWithMetadata.push({
+                tag,
+                position,
+                createdAt: await this.fetchCreatedAt(repositoryPath, token, tag, createdAtByDigest)
+            });
+        }
+        return tagsWithMetadata
+            .sort((left, right) => {
+            const leftTimestamp = left.createdAt ? Date.parse(left.createdAt) : Number.NEGATIVE_INFINITY;
+            const rightTimestamp = right.createdAt ? Date.parse(right.createdAt) : Number.NEGATIVE_INFINITY;
+            if (rightTimestamp !== leftTimestamp) {
+                return rightTimestamp - leftTimestamp;
+            }
+            return left.position - right.position;
+        })
+            .slice(0, limit)
+            .map(({ tag, createdAt }) => ({ tag, createdAt }));
+    }
+    buildImageReference(service, tag) {
+        return buildManagedImageReference(service, tag);
+    }
+    async fetchToken(repositoryPath) {
+        const scope = `repository:${repositoryPath}:pull`;
+        const response = await fetch(`https://public.ecr.aws/token/?service=public.ecr.aws&scope=${encodeURIComponent(scope)}`);
+        if (!response.ok) {
+            throw new Error(`Public registry token request returned ${response.status}.`);
+        }
+        const payload = (await response.json());
+        if (!payload.token) {
+            throw new Error("Public registry token response did not include a token.");
+        }
+        return payload.token;
+    }
+    async fetchCreatedAt(repositoryPath, token, tag, createdAtByDigest) {
+        try {
+            const manifestReference = await this.fetchJson(`https://public.ecr.aws/v2/${repositoryPath}/manifests/${encodeURIComponent(tag)}`, {
+                Authorization: `Bearer ${token}`,
+                Accept: [
+                    "application/vnd.oci.image.index.v1+json",
+                    "application/vnd.docker.distribution.manifest.list.v2+json",
+                    "application/vnd.oci.image.manifest.v1+json",
+                    "application/vnd.docker.distribution.manifest.v2+json"
+                ].join(", ")
+            });
+            const digest = this.selectManifestDigest(manifestReference);
+            const manifest = digest
+                ? await this.fetchJson(`https://public.ecr.aws/v2/${repositoryPath}/manifests/${encodeURIComponent(digest)}`, {
+                    Authorization: `Bearer ${token}`,
+                    Accept: ["application/vnd.oci.image.manifest.v1+json", "application/vnd.docker.distribution.manifest.v2+json"].join(", ")
+                })
+                : manifestReference;
+            const configDigest = "config" in manifest ? manifest.config?.digest : undefined;
+            if (!configDigest) {
+                return undefined;
+            }
+            if (createdAtByDigest.has(configDigest)) {
+                return createdAtByDigest.get(configDigest);
+            }
+            const config = await this.fetchJson(`https://public.ecr.aws/v2/${repositoryPath}/blobs/${configDigest}`, {
+                Authorization: `Bearer ${token}`
+            });
+            createdAtByDigest.set(configDigest, config.created);
+            return config.created;
+        }
+        catch (error) {
+            if (error instanceof PublicRegistryRequestError) {
+                return undefined;
+            }
+            throw error;
+        }
+    }
+    selectManifestDigest(manifest) {
+        if (!("manifests" in manifest) || !manifest.manifests?.length) {
+            return undefined;
+        }
+        return (manifest.manifests.find((entry) => entry.platform?.os === "linux" && entry.platform?.architecture === "amd64")
+            ?.digest ?? manifest.manifests[0]?.digest);
+    }
+    async fetchJson(url, headers) {
+        for (let attempt = 1; attempt <= MAX_FETCH_ATTEMPTS; attempt += 1) {
+            const response = await fetch(url, { headers });
+            if (response.ok) {
+                return (await response.json());
+            }
+            const retryAfterMs = this.parseRetryAfterMs(response);
+            if (attempt < MAX_FETCH_ATTEMPTS && RETRYABLE_STATUS_CODES.has(response.status)) {
+                await this.sleep(retryAfterMs ?? DEFAULT_RETRY_DELAY_MS * attempt);
+                continue;
+            }
+            throw new PublicRegistryRequestError(url, response.status, retryAfterMs);
+        }
+        throw new PublicRegistryRequestError(url, 500);
+    }
+    parseRetryAfterMs(response) {
+        const retryAfter = response.headers.get("retry-after");
+        if (!retryAfter) {
+            return undefined;
+        }
+        const retryAfterSeconds = Number.parseInt(retryAfter, 10);
+        if (Number.isFinite(retryAfterSeconds)) {
+            return Math.max(retryAfterSeconds, 0) * 1000;
+        }
+        const retryAt = Date.parse(retryAfter);
+        if (Number.isNaN(retryAt)) {
+            return undefined;
+        }
+        return Math.max(retryAt - Date.now(), 0);
+    }
+    async sleep(delayMs) {
+        await new Promise((resolve) => setTimeout(resolve, delayMs));
+    }
+}

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

@@ -11,7 +11,7 @@ export interface RuntimeState {
         name: string;
     };
     auth: {
-        username: "admin";
+        username: string;
         password: string;
         jwtPrivateKeyPem: string;
         jwtPublicKeyPem: string;

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

@@ -2,6 +2,7 @@ import type { RuntimeState } from "./RuntimeState.js";
 export declare class RuntimeStateStore {
     private readonly root;
     private readonly runtimePaths;
+    private static readonly DEFAULT_USERNAME;
     constructor(root: string);
     initialize(): RuntimeState;
     load(): RuntimeState | null;

package/dist/core/runtime/RuntimeStateStore.js

@@ -5,6 +5,7 @@ import { createPemKeyPair, randomCompanyId, randomSecret } from "./Secrets.js";
 export class RuntimeStateStore {
     root;
     runtimePaths;
+    static DEFAULT_USERNAME = "admin@local";
     constructor(root) {
         this.root = root;
         this.runtimePaths = new RuntimePaths(root);
@@ -23,7 +24,7 @@ export class RuntimeStateStore {
                 name: "Local CompanyHelm"
             },
             auth: {
-                username: "admin",
+                username: RuntimeStateStore.DEFAULT_USERNAME,
                 password: randomSecret(),
                 jwtPrivateKeyPem: authKeys.privateKeyPem,
                 jwtPublicKeyPem: authKeys.publicKeyPem
@@ -41,7 +42,12 @@ export class RuntimeStateStore {
         if (!fs.existsSync(this.runtimePaths.stateFilePath())) {
             return null;
         }
-        return JSON.parse(fs.readFileSync(this.runtimePaths.stateFilePath(), "utf8"));
+        const state = JSON.parse(fs.readFileSync(this.runtimePaths.stateFilePath(), "utf8"));
+        if (state.auth.username !== RuntimeStateStore.DEFAULT_USERNAME && state.auth.username === "admin") {
+            state.auth.username = RuntimeStateStore.DEFAULT_USERNAME;
+            this.save(state);
+        }
+        return state;
     }
     save(state) {
         fs.writeFileSync(this.runtimePaths.stateFilePath(), `${JSON.stringify(state, null, 2)}\n`, {

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

@@ -0,0 +1,10 @@
+import { type RuntimeImages } from "./ImageCatalog.js";
+export interface RuntimeVersions {
+    cliPackage: string;
+    runnerPackage: string;
+    images: RuntimeImages;
+}
+export declare class VersionCatalog {
+    resolve(): RuntimeVersions;
+    private readPackageVersion;
+}

package/dist/core/runtime/VersionCatalog.js

@@ -0,0 +1,21 @@
+import fs from "node:fs";
+import path from "node:path";
+import { createRequire } from "node:module";
+import { fileURLToPath } from "node:url";
+import { ImageCatalog } from "./ImageCatalog.js";
+const require = createRequire(import.meta.url);
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+export class VersionCatalog {
+    resolve() {
+        return {
+            cliPackage: this.readPackageVersion(path.resolve(__dirname, "../../../package.json")),
+            runnerPackage: this.readPackageVersion(require.resolve("@companyhelm/runner/package.json")),
+            images: new ImageCatalog().resolve()
+        };
+    }
+    readPackageVersion(packageJsonPath) {
+        const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, "utf8"));
+        return `${packageJson.name}@${packageJson.version}`;
+    }
+}

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

@@ -5,8 +5,12 @@ export interface StatusSnapshot {
     frontend: ManagedServiceStatus;
     runner: ManagedServiceStatus;
 }
+export interface StatusOverrides {
+    runner?: () => Promise<boolean> | boolean;
+}
 export declare class StatusService {
     private readonly listRunningServices;
-    constructor(listRunningServices: () => Promise<string>);
+    private readonly overrides;
+    constructor(listRunningServices: () => Promise<string>, overrides?: StatusOverrides);
     read(): Promise<StatusSnapshot>;
 }

package/dist/core/status/StatusService.js

@@ -1,18 +1,21 @@
 export class StatusService {
     listRunningServices;
-    constructor(listRunningServices) {
+    overrides;
+    constructor(listRunningServices, overrides = {}) {
         this.listRunningServices = listRunningServices;
+        this.overrides = overrides;
     }
     async read() {
         const running = new Set((await this.listRunningServices())
             .split("\n")
             .map((service) => service.trim())
             .filter(Boolean));
+        const runnerRunning = this.overrides.runner ? await this.overrides.runner() : running.has("runner");
         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"
+            runner: runnerRunning ? "running" : "stopped"
         };
     }
 }

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

@@ -1,7 +1,17 @@
+import type { StatusReport } from "../../commands/dependencies.js";
 export declare class TerminalRenderer {
     private readonly useColor;
+    private static readonly OSC;
+    private static readonly BEL;
     constructor(useColor?: boolean);
     renderBanner(): string;
     success(message: string): string;
+    progress(message: string): string;
+    successHighlight(message: string): string;
+    clickableUrl(url: string): string;
+    renderStatus(report: StatusReport): string;
+    private renderServiceLine;
+    private warn;
+    private formatDetail;
     private colorize;
 }