@companyhelm/cli 0.3.0 → 0.4.1

package/dist/commands/dependencies.js

@@ -1,6 +1,4 @@
 import fs from "node:fs";
-import os from "node:os";
-import path from "node:path";
 import { DeploymentBootstrapper } from "../core/bootstrap/DeploymentBootstrapper.js";
 import { ApiEnvFileWriter } from "../core/config/ApiEnvFileWriter.js";
 import { GithubAppConfigStore } from "../core/config/GithubAppConfigStore.js";
@@ -11,8 +9,8 @@ import { LocalServiceProcessManager } from "../core/local/LocalServiceProcessMan
 import { WebLocalService } from "../core/local/WebLocalService.js";
 import { LogsService } from "../core/logs/LogsService.js";
 import { CommandRunner } from "../core/process/CommandRunner.js";
-import { ProjectPaths } from "../core/runtime/ProjectPaths.js";
 import { RunnerSupervisor } from "../core/runner/RunnerSupervisor.js";
+import { defaultCliRoot } from "../core/runtime/CliRoot.js";
 import { createPasswordHash } from "../core/runtime/Secrets.js";
 import { RuntimePaths } from "../core/runtime/RuntimePaths.js";
 import { RuntimeStateStore } from "../core/runtime/RuntimeStateStore.js";
@@ -25,7 +23,7 @@ import { runStartupPreflightChecks } from "../preflight/runStartupPreflightCheck
 import { ensureGithubAppConfig } from "./setup-github-app.js";
 import { ensureAgentWorkspaceMode } from "./startup-preferences.js";
 function runtimeRoot() {
-    return process.env.COMPANYHELM_HOME || path.join(os.homedir(), ".companyhelm");
+    return defaultCliRoot();
 }
 export function createDefaultDependencies() {
     const root = runtimeRoot();
@@ -37,10 +35,9 @@ export function createDefaultDependencies() {
     const runnerSupervisor = new RunnerSupervisor(runtimePaths.runnerConfigPath());
     const bootstrapper = new DeploymentBootstrapper();
     const githubAppConfigStore = new GithubAppConfigStore();
-    const apiEnvFileWriter = new ApiEnvFileWriter(process.cwd());
-    const projectPaths = new ProjectPaths(process.cwd());
+    const apiEnvFileWriter = new ApiEnvFileWriter(root);
     const localRepoSourceResolver = new LocalRepoSourceResolver(process.cwd());
-    const localConfigStore = new LocalConfigStore(root);
+    const localConfigStore = new LocalConfigStore();
     const localServiceProcessManager = new LocalServiceProcessManager();
     const apiLocalService = new ApiLocalService(localServiceProcessManager, commandRunner);
     const webLocalService = new WebLocalService(localServiceProcessManager, commandRunner);
@@ -157,7 +154,7 @@ export function createDefaultDependencies() {
                     await commandRunner.run(configureSdkCommand.command, configureSdkCommand.args);
                     const startCommand = runnerSupervisor.buildStartArgs({
                         serverUrl: `127.0.0.1:${state.ports.runnerGrpc}`,
-                        agentApiUrl: `127.0.0.1:${state.ports.agentCliGrpc}`,
+                        agentApiUrl: `http://127.0.0.1:${state.ports.apiHttp}/agent/v1`,
                         logPath: runtimePaths.runnerLogPath(),
                         secret: state.runner.secret,
                         logLevel,
@@ -264,7 +261,6 @@ export function createDefaultDependencies() {
                 await stopLocalServicesFromState(state, localServiceProcessManager);
             }
             await dockerStackManager.down({ removeVolumes: true });
-            fs.rmSync(projectPaths.apiEnvPath(), { force: true });
             fs.rmSync(localConfigStore.configPath(), { force: true });
             fs.rmSync(root, { recursive: true, force: true });
             if (options.removeGithubAppConfig) {

package/dist/commands/reset.js

@@ -4,7 +4,7 @@ import { requireInteractiveTerminal, unwrapPromptResult } from "./interactive.js
 export async function confirmReset(input = process.stdin, output = process.stdout) {
     requireInteractiveTerminal(input, output, "reset requires confirmation from a TTY. Re-run with --yes to skip the prompt.");
     const confirmed = await clack.confirm({
-        message: "This will remove CompanyHelm containers, Postgres data, local runtime state, generated .companyhelm/api/.env, and the CompanyHelm home config. Continue?",
+        message: "This will remove CompanyHelm containers, Postgres data, generated runtime files under ~/.companyhelm/cli/runtime, and the CLI workspace config under ~/.companyhelm/cli/config.yaml. Continue?",
         active: "Yes",
         inactive: "No",
         initialValue: false,

package/dist/commands/set-image-version.d.ts

@@ -13,7 +13,7 @@ export interface InteractiveImageSelector {
     listAvailableTags(service: ManagedImageService, limit: number): Promise<AvailableImageTag[]>;
     buildImageReference(service: ManagedImageService, tag: string): string;
 }
-export interface ImageConfigStore {
+export interface ImageVersionStore {
     load(): {
         images: Partial<Record<ManagedImageService, string>>;
     };
@@ -26,6 +26,6 @@ export declare function runSetImageVersion(options: SetImageVersionOptions, depe
     input?: Readable;
     output?: Writable;
     registry?: InteractiveImageSelector;
-    configStore?: ImageConfigStore;
+    configStore?: ImageVersionStore;
 }): Promise<void>;
 export declare function registerSetImageVersionCommand(program: Command): void;

package/dist/commands/set-image-version.js

@@ -1,7 +1,7 @@
 import * as clack from "@clack/prompts";
-import { LocalConfigStore } from "../core/runtime/LocalConfigStore.js";
 import { MANAGED_IMAGE_SERVICES, requireManagedImageService } from "../core/runtime/ManagedImages.js";
 import { PublicImageTagRegistry } from "../core/runtime/PublicImageTagRegistry.js";
+import { ImageConfigStore } from "../core/runtime/ImageConfigStore.js";
 import { requireInteractiveTerminal, unwrapPromptResult } from "./interactive.js";
 function parsePositiveInteger(value) {
     const parsed = Number.parseInt(value, 10);
@@ -59,7 +59,7 @@ export async function runSetImageVersion(options, dependencies = {}) {
     const input = dependencies.input ?? process.stdin;
     const output = dependencies.output ?? process.stdout;
     const registry = dependencies.registry ?? new PublicImageTagRegistry();
-    const configStore = dependencies.configStore ?? new LocalConfigStore();
+    const configStore = dependencies.configStore ?? new ImageConfigStore();
     clack.intro("CompanyHelm image selection", { output });
     const selectedService = options.service
         ? requireManagedImageService(options.service)
@@ -78,7 +78,7 @@ export async function runSetImageVersion(options, dependencies = {}) {
 export function registerSetImageVersionCommand(program) {
     program
         .command("set-image-version")
-        .description("Interactively choose an API or frontend image tag and store it in the CompanyHelm home config.")
+        .description("Interactively choose an API or frontend image tag and store it in the packaged image config.")
         .option("-s, --service <service>", "Prefill the service to update (api or frontend)")
         .option("-l, --limit <count>", "How many image tags to show", parsePositiveInteger, 20)
         .action(async (options) => {

package/dist/config/image_config.d.ts

@@ -0,0 +1,4 @@
+export declare const PACKAGED_IMAGE_CONFIG: {
+    readonly api: "public.ecr.aws/x6n0f2k4/companyhelm-api:0.6.1";
+    readonly frontend: "public.ecr.aws/x6n0f2k4/companyhelm-web:0.1.1";
+};

package/dist/config/image_config.js

@@ -0,0 +1,4 @@
+export const PACKAGED_IMAGE_CONFIG = {
+    api: "public.ecr.aws/x6n0f2k4/companyhelm-api:0.6.1",
+    frontend: "public.ecr.aws/x6n0f2k4/companyhelm-web:0.1.1"
+};

package/dist/core/bootstrap/DeploymentBootstrapper.d.ts

@@ -8,7 +8,6 @@ export declare class DeploymentBootstrapper {
         databaseHost?: string;
         appPort?: number;
         runnerGrpcPort?: number;
-        agentGrpcPort?: number;
         githubAppConfig?: GithubAppConfig | null;
     }): string;
     writeFrontendConfig(root: string, state: RuntimeState): string;

package/dist/core/bootstrap/DeploymentBootstrapper.js

@@ -23,7 +23,6 @@ export class DeploymentBootstrapper {
         const outputPath = runtimePaths.apiConfigPath();
         const appPort = options.appPort ?? state.ports.apiHttp;
         const runnerGrpcPort = options.runnerGrpcPort ?? state.ports.runnerGrpc;
-        const agentGrpcPort = options.agentGrpcPort ?? state.ports.agentCliGrpc;
         const databaseHost = options.databaseHost ?? "postgres";
         const githubConfigLines = options.githubAppConfig
             ? [
@@ -59,10 +58,6 @@ export class DeploymentBootstrapper {
             "      jitterSeconds: 60",
             "      batchSize: 10",
             "      leaseSeconds: 120",
-            "agent:",
-            "  grpc:",
-            '    host: "0.0.0.0"',
-            `    port: ${agentGrpcPort}`,
             "database:",
             '  name: "companyhelm"',
             `  host: "${databaseHost}"`,

package/dist/core/config/ApiEnvFileWriter.d.ts

@@ -1,6 +1,8 @@
 import type { GithubAppConfig } from "./GithubAppConfig.js";
 export declare class ApiEnvFileWriter {
-    private readonly projectPaths;
-    constructor(projectRoot?: string);
+    private readonly runtimePaths;
+    private readonly templatePath;
+    constructor(root: string);
     write(config: GithubAppConfig | null): string;
+    private render;
 }

package/dist/core/config/ApiEnvFileWriter.js

@@ -1,5 +1,7 @@
 import fs from "node:fs";
-import { ProjectPaths } from "../runtime/ProjectPaths.js";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { RuntimePaths } from "../runtime/RuntimePaths.js";
 function escapeEnvValue(value) {
     return String(value || "")
         .replace(/\\/g, "\\\\")
@@ -8,19 +10,24 @@ function escapeEnvValue(value) {
         .replace(/\n/g, "\\n");
 }
 export class ApiEnvFileWriter {
-    projectPaths;
-    constructor(projectRoot = process.cwd()) {
-        this.projectPaths = new ProjectPaths(projectRoot);
+    runtimePaths;
+    templatePath;
+    constructor(root) {
+        this.runtimePaths = new RuntimePaths(root);
+        this.templatePath = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "../../templates/api.env.tpl");
     }
     write(config) {
-        fs.mkdirSync(this.projectPaths.apiDirectoryPath(), { recursive: true });
-        const contents = [
-            `GITHUB_APP_URL=${escapeEnvValue(config?.appUrl ?? "")}`,
-            `GITHUB_APP_CLIENT_ID=${escapeEnvValue(config?.appClientId ?? "")}`,
-            `GITHUB_APP_PRIVATE_KEY_PEM=${escapeEnvValue(config?.appPrivateKeyPem ?? "")}`,
-            "",
-        ].join("\n");
-        fs.writeFileSync(this.projectPaths.apiEnvPath(), contents, "utf8");
-        return this.projectPaths.apiEnvPath();
+        fs.mkdirSync(this.runtimePaths.apiDirectoryPath(), { recursive: true });
+        const contents = this.render(config);
+        fs.writeFileSync(this.runtimePaths.apiEnvPath(), contents, "utf8");
+        return this.runtimePaths.apiEnvPath();
+    }
+    render(config) {
+        const template = fs.readFileSync(this.templatePath, "utf8");
+        const rendered = template
+            .replace("{{GITHUB_APP_URL}}", escapeEnvValue(config?.appUrl ?? ""))
+            .replace("{{GITHUB_APP_CLIENT_ID}}", escapeEnvValue(config?.appClientId ?? ""))
+            .replace("{{GITHUB_APP_PRIVATE_KEY_PEM}}", escapeEnvValue(config?.appPrivateKeyPem ?? ""));
+        return rendered.endsWith("\n") ? rendered : `${rendered}\n`;
     }
 }

package/dist/core/config/GithubAppConfigStore.js

@@ -1,18 +1,10 @@
 import fs from "node:fs";
-import os from "node:os";
 import path from "node:path";
 import { parse, stringify } from "yaml";
 import { normalizeGithubAppConfig } from "./GithubAppConfig.js";
+import { defaultCliConfigRoot } from "../runtime/CliRoot.js";
 function defaultConfigRoot() {
-    const explicitRoot = String(process.env.COMPANYHELM_CONFIG_HOME || "").trim();
-    if (explicitRoot) {
-        return path.resolve(explicitRoot);
-    }
-    const xdgRoot = String(process.env.XDG_CONFIG_HOME || "").trim();
-    if (xdgRoot) {
-        return path.resolve(xdgRoot, "companyhelm");
-    }
-    return path.join(os.homedir(), ".config", "companyhelm");
+    return defaultCliConfigRoot();
 }
 export class GithubAppConfigStore {
     configRoot;

package/dist/core/docker/ComposeTemplateRenderer.js

@@ -29,7 +29,6 @@ export class ComposeTemplateRenderer {
             "    ports:",
             `      - "${ports.apiHttpPort}:4000"`,
             `      - "${ports.runnerGrpcPort}:${ports.runnerGrpcPort}"`,
-            `      - "${ports.agentCliGrpcPort}:${ports.agentCliGrpcPort}"`,
             "    volumes:",
             `      - "${paths.apiConfigPath}:/run/companyhelm/config.yaml:ro"`,
             "    networks:",

package/dist/core/docker/DockerStackManager.js

@@ -1,6 +1,5 @@
 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 {
@@ -23,7 +22,7 @@ export class DockerStackManager {
             agentCliGrpcPort: state.ports.agentCliGrpc
         }, {
             apiConfigPath: this.runtimePaths.apiConfigPath(),
-            apiEnvPath: new ProjectPaths(process.cwd()).apiEnvPath(),
+            apiEnvPath: this.runtimePaths.apiEnvPath(),
             frontendConfigPath: this.runtimePaths.frontendConfigPath(),
             seedFilePath: this.runtimePaths.seedFilePath()
         }, {

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

@@ -0,0 +1,2 @@
+export declare function defaultCliRoot(): string;
+export declare function defaultCliConfigRoot(): string;

package/dist/core/runtime/CliRoot.js

@@ -0,0 +1,23 @@
+import os from "node:os";
+import path from "node:path";
+function defaultCliBaseRoot() {
+    return path.join(os.homedir(), ".companyhelm", "cli");
+}
+export function defaultCliRoot() {
+    const explicitRoot = String(process.env.COMPANYHELM_HOME || "").trim();
+    if (explicitRoot) {
+        return path.resolve(explicitRoot);
+    }
+    return path.join(defaultCliBaseRoot(), "runtime");
+}
+export function defaultCliConfigRoot() {
+    const explicitRoot = String(process.env.COMPANYHELM_CONFIG_HOME || "").trim();
+    if (explicitRoot) {
+        return path.resolve(explicitRoot);
+    }
+    const explicitRuntimeRoot = String(process.env.COMPANYHELM_HOME || "").trim();
+    if (explicitRuntimeRoot) {
+        return path.resolve(explicitRuntimeRoot);
+    }
+    return defaultCliBaseRoot();
+}

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

@@ -1,8 +1,11 @@
+import { ImageConfigStore } from "./ImageConfigStore.js";
 export interface RuntimeImages {
     api: string;
     frontend: string;
     postgres: string;
 }
 export declare class ImageCatalog {
+    private readonly configStore;
+    constructor(configStore?: ImageConfigStore);
     resolve(): RuntimeImages;
 }

package/dist/core/runtime/ImageCatalog.js

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

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

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

package/dist/core/runtime/ImageConfigStore.js

@@ -0,0 +1,51 @@
+import fs from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { MANAGED_IMAGE_SERVICES, defaultManagedImageReference } from "./ManagedImages.js";
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+function defaultPackageRoot() {
+    return path.resolve(__dirname, "../../..");
+}
+export class ImageConfigStore {
+    root;
+    constructor(root = defaultPackageRoot()) {
+        this.root = root;
+    }
+    configPath() {
+        return path.join(this.root, "src", "config", "image_config.ts");
+    }
+    load() {
+        const configPath = this.configPath();
+        if (!fs.existsSync(configPath)) {
+            return { images: {} };
+        }
+        const images = {};
+        for (const rawLine of fs.readFileSync(configPath, "utf8").split(/\r?\n/)) {
+            const match = rawLine.match(/^\s+(api|frontend):\s+"([^"]+)",?$/);
+            if (match) {
+                images[match[1]] = match[2];
+            }
+        }
+        return { images };
+    }
+    setImage(service, image) {
+        const nextConfig = this.load();
+        nextConfig.images[service] = image;
+        this.save(nextConfig);
+        return { configPath: this.configPath(), image };
+    }
+    save(config) {
+        const lines = [
+            "export const PACKAGED_IMAGE_CONFIG = {",
+            ...MANAGED_IMAGE_SERVICES.map((service) => {
+                const image = config.images[service] ?? defaultManagedImageReference(service);
+                return `  ${service}: "${image}"`;
+            }).map((line, index, all) => `${line}${index < all.length - 1 ? "," : ""}`),
+            "} as const;",
+            ""
+        ];
+        fs.mkdirSync(path.dirname(this.configPath()), { recursive: true });
+        fs.writeFileSync(this.configPath(), lines.join("\n"), "utf8");
+    }
+}

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

@@ -1,18 +1,12 @@
-import type { ManagedImageService } from "./ManagedImages.js";
 export type AgentWorkspaceMode = "dedicated" | "current-working-directory";
 export interface LocalConfig {
     agentWorkspaceMode?: AgentWorkspaceMode;
-    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;
-    };
     setAgentWorkspaceMode(agentWorkspaceMode: AgentWorkspaceMode): {
         configPath: string;
         agentWorkspaceMode: AgentWorkspaceMode;

package/dist/core/runtime/LocalConfigStore.js

@@ -1,8 +1,8 @@
 import fs from "node:fs";
-import os from "node:os";
 import path from "node:path";
+import { defaultCliConfigRoot } from "./CliRoot.js";
 function defaultLocalConfigRoot() {
-    return process.env.COMPANYHELM_HOME || path.join(os.homedir(), ".companyhelm");
+    return defaultCliConfigRoot();
 }
 export class LocalConfigStore {
     root;
@@ -15,16 +15,10 @@ export class LocalConfigStore {
     load() {
         const configPath = this.configPath();
         if (!fs.existsSync(configPath)) {
-            return { images: {} };
+            return {};
         }
         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 };
-    }
     setAgentWorkspaceMode(agentWorkspaceMode) {
         const nextConfig = this.load();
         nextConfig.agentWorkspaceMode = agentWorkspaceMode;
@@ -36,48 +30,21 @@ export class LocalConfigStore {
         if (config.agentWorkspaceMode) {
             lines.push(`agent_workspace_mode: ${config.agentWorkspaceMode}`);
         }
-        lines.push("images:");
-        if (config.images.api) {
-            lines.push(`  api: ${config.images.api}`);
-        }
-        if (config.images.frontend) {
-            lines.push(`  frontend: ${config.images.frontend}`);
-        }
         fs.mkdirSync(path.dirname(this.configPath()), { recursive: true });
         fs.writeFileSync(this.configPath(), `${lines.join("\n")}\n`, "utf8");
     }
     parse(content) {
-        const images = {};
         let agentWorkspaceMode;
-        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;
-            }
             const workspaceModeMatch = line.match(/^agent_workspace_mode:\s*(dedicated|current-working-directory)$/);
             if (workspaceModeMatch) {
                 agentWorkspaceMode = workspaceModeMatch[1];
-                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 {
-            agentWorkspaceMode,
-            images
-        };
+        return { agentWorkspaceMode };
     }
 }

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

@@ -12,5 +12,6 @@ export declare class PublicImageTagRegistry {
     private fetchJson;
     private parseRetryAfterMs;
     private sleep;
+    private mapWithConcurrency;
 }
 export {};

package/dist/core/runtime/PublicImageTagRegistry.js

@@ -2,6 +2,7 @@ import { buildManagedImageReference, getManagedImageDefinition } from "./Managed
 const RETRYABLE_STATUS_CODES = new Set([429, 500, 502, 503, 504]);
 const MAX_FETCH_ATTEMPTS = 3;
 const DEFAULT_RETRY_DELAY_MS = 250;
+const METADATA_FETCH_CONCURRENCY = 6;
 class PublicRegistryRequestError extends Error {
     status;
     retryAfterMs;
@@ -31,15 +32,13 @@ export class PublicImageTagRegistry {
             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 candidateTags = uniqueTags.slice(0, limit);
         const createdAtByDigest = new Map();
-        const tagsWithMetadata = [];
-        for (const { tag, position } of uniqueTags) {
-            tagsWithMetadata.push({
-                tag,
-                position,
-                createdAt: await this.fetchCreatedAt(repositoryPath, token, tag, createdAtByDigest)
-            });
-        }
+        const tagsWithMetadata = await this.mapWithConcurrency(candidateTags, METADATA_FETCH_CONCURRENCY, async ({ tag, position }) => ({
+            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;
@@ -49,7 +48,6 @@ export class PublicImageTagRegistry {
             }
             return left.position - right.position;
         })
-            .slice(0, limit)
             .map(({ tag, createdAt }) => ({ tag, createdAt }));
     }
     buildImageReference(service, tag) {
@@ -89,14 +87,20 @@ export class PublicImageTagRegistry {
             if (!configDigest) {
                 return undefined;
             }
-            if (createdAtByDigest.has(configDigest)) {
-                return createdAtByDigest.get(configDigest);
+            const existingCreatedAt = createdAtByDigest.get(configDigest);
+            if (existingCreatedAt) {
+                return await existingCreatedAt;
             }
-            const config = await this.fetchJson(`https://public.ecr.aws/v2/${repositoryPath}/blobs/${configDigest}`, {
+            const createdAtPromise = this.fetchJson(`https://public.ecr.aws/v2/${repositoryPath}/blobs/${configDigest}`, {
                 Authorization: `Bearer ${token}`
+            })
+                .then((config) => config.created)
+                .catch((error) => {
+                createdAtByDigest.delete(configDigest);
+                throw error;
             });
-            createdAtByDigest.set(configDigest, config.created);
-            return config.created;
+            createdAtByDigest.set(configDigest, createdAtPromise);
+            return await createdAtPromise;
         }
         catch (error) {
             if (error instanceof PublicRegistryRequestError) {
@@ -145,4 +149,20 @@ export class PublicImageTagRegistry {
     async sleep(delayMs) {
         await new Promise((resolve) => setTimeout(resolve, delayMs));
     }
+    async mapWithConcurrency(items, concurrency, mapper) {
+        if (items.length === 0) {
+            return [];
+        }
+        const results = new Array(items.length);
+        let nextIndex = 0;
+        const workerCount = Math.min(concurrency, items.length);
+        await Promise.all(Array.from({ length: workerCount }, async () => {
+            while (nextIndex < items.length) {
+                const currentIndex = nextIndex;
+                nextIndex += 1;
+                results[currentIndex] = await mapper(items[currentIndex], currentIndex);
+            }
+        }));
+        return results;
+    }
 }

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

@@ -3,6 +3,8 @@ export declare class RuntimePaths {
     constructor(root: string);
     stateFilePath(): string;
     composeFilePath(): string;
+    apiDirectoryPath(): string;
+    apiEnvPath(): string;
     apiConfigPath(): string;
     frontendConfigPath(): string;
     seedFilePath(): string;

package/dist/core/runtime/RuntimePaths.js

@@ -10,6 +10,12 @@ export class RuntimePaths {
     composeFilePath() {
         return path.join(this.root, "docker-compose.yaml");
     }
+    apiDirectoryPath() {
+        return path.join(this.root, "api");
+    }
+    apiEnvPath() {
+        return path.join(this.apiDirectoryPath(), ".env");
+    }
     apiConfigPath() {
         return path.join(this.root, "api-config.yaml");
     }

package/dist/templates/api.env.tpl

@@ -0,0 +1,3 @@
+GITHUB_APP_URL={{GITHUB_APP_URL}}
+GITHUB_APP_CLIENT_ID={{GITHUB_APP_CLIENT_ID}}
+GITHUB_APP_PRIVATE_KEY_PEM={{GITHUB_APP_PRIVATE_KEY_PEM}}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@companyhelm/cli",
-  "version": "0.3.0",
+  "version": "0.4.1",
   "description": "Bootstrap and manage a local CompanyHelm deployment.",
   "license": "MIT",
   "private": false,
@@ -17,17 +17,18 @@
   },
   "files": [
     "dist",
-    "src/templates"
+    "src/templates",
+    "src/config/image_config.ts"
   ],
   "scripts": {
-    "build": "tsc -p tsconfig.json && node scripts/copy-templates.cjs",
+    "build": "rm -rf dist && tsc -p tsconfig.json && node scripts/copy-templates.cjs",
     "set-image-version": "npm run build && node dist/cli.js set-image-version",
     "start": "npm run build && node dist/cli.js",
     "test": "npm run build && vitest run"
   },
   "dependencies": {
     "@clack/prompts": "^1.1.0",
-    "@companyhelm/runner": "^0.1.3",
+    "@companyhelm/runner": "^0.2.0",
     "chalk": "^5.6.2",
     "commander": "^14.0.1",
     "dockerode": "^4.0.9",

package/src/config/image_config.ts

@@ -0,0 +1,4 @@
+export const PACKAGED_IMAGE_CONFIG = {
+  api: "public.ecr.aws/x6n0f2k4/companyhelm-api:0.6.1",
+  frontend: "public.ecr.aws/x6n0f2k4/companyhelm-web:0.1.1"
+} as const;

package/src/templates/api.env.tpl

@@ -0,0 +1,3 @@
+GITHUB_APP_URL={{GITHUB_APP_URL}}
+GITHUB_APP_CLIENT_ID={{GITHUB_APP_CLIENT_ID}}
+GITHUB_APP_PRIVATE_KEY_PEM={{GITHUB_APP_PRIVATE_KEY_PEM}}

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

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

package/dist/core/runtime/ProjectPaths.js

@@ -1,16 +0,0 @@
-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");
-    }
-}