Lyon
edfddd2445
* docs: specify cicd yaml target governance * fix: resolve cicd targets from yaml --------- Co-authored-by: Codex <codex@noreply.local>
237 lines
10 KiB
TypeScript
237 lines
10 KiB
TypeScript
// SPEC: PJ2026-01060308 cicd-yaml-targets draft-2026-06-25-cicd-yaml-targets.
|
|
// Responsibility: YAML-backed target resolvers shared by CI/CD control-plane commands.
|
|
import { readFileSync } from "node:fs";
|
|
import { rootPath } from "../config";
|
|
import { configRefSummary } from "./config-refs";
|
|
|
|
export const CICD_TARGETS_CONFIG_PATH = "config/cicd/targets.yaml";
|
|
export const ARTIFACT_REGISTRY_CONFIG_PATH = "config/artifact-registry.yaml";
|
|
|
|
export interface TargetConfigSource {
|
|
configPath: string;
|
|
targetPath: string;
|
|
defaultPath: string;
|
|
defaulted: boolean;
|
|
}
|
|
|
|
export interface ResolvedCicdTarget {
|
|
targetId: string;
|
|
providerId: string;
|
|
kubeRoute: string;
|
|
kubeconfig: string;
|
|
hostCwd: string;
|
|
homeDir: string;
|
|
pipelineManifest: string;
|
|
codeQueueImage: string;
|
|
guardName: string;
|
|
requiredNodeName?: string;
|
|
requiredNodeLabel?: { key: string; value: string };
|
|
artifactRegistryConfigRef?: string;
|
|
configSource: TargetConfigSource;
|
|
}
|
|
|
|
export interface ResolvedArtifactRegistryTarget {
|
|
targetId: string;
|
|
providerId: string;
|
|
mode: string;
|
|
host: string;
|
|
port: number;
|
|
endpoint: string;
|
|
image: string;
|
|
repositoryPrefix: string;
|
|
baseDir: string;
|
|
storageDir: string;
|
|
unitName: string;
|
|
composeProject: string;
|
|
serviceName: string;
|
|
containerName: string;
|
|
timeoutMs: number;
|
|
sourceRepo: string;
|
|
consumerTarget: Record<string, unknown>;
|
|
consumerCatalogRef: string;
|
|
configSource: TargetConfigSource;
|
|
}
|
|
|
|
interface CodedTargetConfig<T> {
|
|
defaults: { targetId: string };
|
|
targets: Record<string, T>;
|
|
}
|
|
|
|
export function resolveCicdTarget(selection: string | null | undefined): ResolvedCicdTarget {
|
|
const config = readTargetConfig(CICD_TARGETS_CONFIG_PATH, "UnideskCicdTargets");
|
|
const { targetId, record, defaulted } = selectTarget(config, selection, CICD_TARGETS_CONFIG_PATH);
|
|
const label = `targets.${targetId}`;
|
|
const requiredNodeLabel = optionalRecord(record.requiredNodeLabel, `${label}.requiredNodeLabel`);
|
|
return {
|
|
targetId,
|
|
providerId: stringField(record, "providerId", label),
|
|
kubeRoute: stringField(record, "kubeRoute", label),
|
|
kubeconfig: absolutePathField(record, "kubeconfig", label),
|
|
hostCwd: absolutePathField(record, "hostCwd", label),
|
|
homeDir: absolutePathField(record, "homeDir", label),
|
|
pipelineManifest: stringField(record, "pipelineManifest", label),
|
|
codeQueueImage: stringField(record, "codeQueueImage", label),
|
|
guardName: stringField(record, "guardName", label),
|
|
...(record.requiredNodeName === undefined ? {} : { requiredNodeName: stringField(record, "requiredNodeName", label) }),
|
|
...(requiredNodeLabel === undefined
|
|
? {}
|
|
: { requiredNodeLabel: { key: stringField(requiredNodeLabel, "key", `${label}.requiredNodeLabel`), value: stringField(requiredNodeLabel, "value", `${label}.requiredNodeLabel`) } }),
|
|
...(record.artifactRegistry === undefined
|
|
? {}
|
|
: { artifactRegistryConfigRef: stringField(asRecord(record.artifactRegistry, `${label}.artifactRegistry`), "configRef", `${label}.artifactRegistry`) }),
|
|
configSource: configSource(CICD_TARGETS_CONFIG_PATH, targetId, defaulted),
|
|
};
|
|
}
|
|
|
|
export function resolveArtifactRegistryTarget(selection: string | null | undefined): ResolvedArtifactRegistryTarget {
|
|
const config = readTargetConfig(ARTIFACT_REGISTRY_CONFIG_PATH, "UnideskArtifactRegistry");
|
|
const { targetId, record, defaulted } = selectTarget(config, selection, ARTIFACT_REGISTRY_CONFIG_PATH);
|
|
const label = `targets.${targetId}`;
|
|
const registry = asRecord(record.registry, `${label}.registry`);
|
|
const runtime = asRecord(record.runtime, `${label}.runtime`);
|
|
const source = asRecord(record.source, `${label}.source`);
|
|
const consumers = asRecord(record.consumers, `${label}.consumers`);
|
|
return {
|
|
targetId,
|
|
providerId: stringField(record, "providerId", label),
|
|
mode: stringField(record, "mode", label),
|
|
host: stringField(registry, "host", `${label}.registry`),
|
|
port: portField(registry, "port", `${label}.registry`),
|
|
endpoint: stringField(registry, "endpoint", `${label}.registry`),
|
|
image: stringField(registry, "image", `${label}.registry`),
|
|
repositoryPrefix: stringField(registry, "repositoryPrefix", `${label}.registry`),
|
|
baseDir: absolutePathField(runtime, "baseDir", `${label}.runtime`),
|
|
storageDir: absolutePathField(runtime, "storageDir", `${label}.runtime`),
|
|
unitName: stringField(runtime, "unitName", `${label}.runtime`),
|
|
composeProject: stringField(runtime, "composeProject", `${label}.runtime`),
|
|
serviceName: stringField(runtime, "serviceName", `${label}.runtime`),
|
|
containerName: stringField(runtime, "containerName", `${label}.runtime`),
|
|
timeoutMs: positiveIntegerField(runtime, "timeoutMs", `${label}.runtime`),
|
|
sourceRepo: stringField(source, "repo", `${label}.source`),
|
|
consumerTarget: asRecord(consumers.target, `${label}.consumers.target`),
|
|
consumerCatalogRef: stringField(consumers, "catalogRef", `${label}.consumers`),
|
|
configSource: configSource(ARTIFACT_REGISTRY_CONFIG_PATH, targetId, defaulted),
|
|
};
|
|
}
|
|
|
|
export function targetSourceSummary(target: { configSource: TargetConfigSource }): Record<string, unknown> {
|
|
return {
|
|
configPath: target.configSource.configPath,
|
|
targetPath: target.configSource.targetPath,
|
|
defaultPath: target.configSource.defaultPath,
|
|
defaulted: target.configSource.defaulted,
|
|
};
|
|
}
|
|
|
|
export function cicdTargetSummary(target: ResolvedCicdTarget): Record<string, unknown> {
|
|
return {
|
|
targetId: target.targetId,
|
|
providerId: target.providerId,
|
|
kubeRoute: target.kubeRoute,
|
|
kubeconfig: target.kubeconfig,
|
|
hostCwd: target.hostCwd,
|
|
homeDir: target.homeDir,
|
|
pipelineManifest: target.pipelineManifest,
|
|
codeQueueImage: target.codeQueueImage,
|
|
guardName: target.guardName,
|
|
requiredNodeName: target.requiredNodeName ?? null,
|
|
requiredNodeLabel: target.requiredNodeLabel ?? null,
|
|
artifactRegistryConfigRef: target.artifactRegistryConfigRef === undefined ? null : configRefSummary(target.artifactRegistryConfigRef, `${target.configSource.targetPath}.artifactRegistry.configRef`),
|
|
source: targetSourceSummary(target),
|
|
};
|
|
}
|
|
|
|
export function artifactRegistryTargetSummary(target: ResolvedArtifactRegistryTarget): Record<string, unknown> {
|
|
return {
|
|
targetId: target.targetId,
|
|
providerId: target.providerId,
|
|
mode: target.mode,
|
|
registry: {
|
|
image: target.image,
|
|
host: target.host,
|
|
port: target.port,
|
|
endpoint: target.endpoint,
|
|
repositoryPrefix: target.repositoryPrefix,
|
|
},
|
|
runtime: {
|
|
baseDir: target.baseDir,
|
|
storageDir: target.storageDir,
|
|
unitName: target.unitName,
|
|
composeProject: target.composeProject,
|
|
serviceName: target.serviceName,
|
|
containerName: target.containerName,
|
|
timeoutMs: target.timeoutMs,
|
|
},
|
|
consumerTarget: target.consumerTarget,
|
|
consumerCatalogRef: target.consumerCatalogRef,
|
|
source: targetSourceSummary(target),
|
|
};
|
|
}
|
|
|
|
function readTargetConfig(path: string, expectedKind: string): CodedTargetConfig<Record<string, unknown>> {
|
|
const parsed = Bun.YAML.parse(readFileSync(rootPath(path), "utf8")) as unknown;
|
|
const root = asRecord(parsed, path);
|
|
const version = root.version;
|
|
if (version !== 1) throw new Error(`${path}.version must be 1`);
|
|
if (root.kind !== expectedKind) throw new Error(`${path}.kind must be ${expectedKind}`);
|
|
const defaults = asRecord(root.defaults, `${path}.defaults`);
|
|
const targets = asRecord(root.targets, `${path}.targets`);
|
|
const config = {
|
|
defaults: { targetId: stringField(defaults, "targetId", `${path}.defaults`) },
|
|
targets: Object.fromEntries(Object.entries(targets).map(([key, value]) => [key, asRecord(value, `${path}.targets.${key}`)])),
|
|
};
|
|
if (config.targets[config.defaults.targetId] === undefined) throw new Error(`${path}.defaults.targetId references missing target ${config.defaults.targetId}`);
|
|
return config;
|
|
}
|
|
|
|
function selectTarget(config: CodedTargetConfig<Record<string, unknown>>, selection: string | null | undefined, path: string): { targetId: string; record: Record<string, unknown>; defaulted: boolean } {
|
|
const raw = selection === undefined || selection === null || selection.length === 0 ? config.defaults.targetId : selection;
|
|
const targetId = Object.keys(config.targets).find((candidate) => candidate.toLowerCase() === raw.toLowerCase())
|
|
?? Object.entries(config.targets).find(([, target]) => typeof target.providerId === "string" && target.providerId.toLowerCase() === raw.toLowerCase())?.[0];
|
|
if (targetId === undefined) throw new Error(`${path} has no target ${raw}; known targets: ${Object.keys(config.targets).join(", ")}`);
|
|
return { targetId, record: config.targets[targetId], defaulted: raw === config.defaults.targetId && (selection === undefined || selection === null || selection.length === 0) };
|
|
}
|
|
|
|
function configSource(path: string, targetId: string, defaulted: boolean): TargetConfigSource {
|
|
return {
|
|
configPath: path,
|
|
targetPath: `${path}#targets.${targetId}`,
|
|
defaultPath: `${path}#defaults.targetId`,
|
|
defaulted,
|
|
};
|
|
}
|
|
|
|
function asRecord(value: unknown, path: string): Record<string, unknown> {
|
|
if (typeof value !== "object" || value === null || Array.isArray(value)) throw new Error(`${path} must be an object`);
|
|
return value as Record<string, unknown>;
|
|
}
|
|
|
|
function optionalRecord(value: unknown, path: string): Record<string, unknown> | undefined {
|
|
if (value === undefined || value === null) return undefined;
|
|
return asRecord(value, path);
|
|
}
|
|
|
|
function stringField(record: Record<string, unknown>, key: string, path: string): string {
|
|
const value = record[key];
|
|
if (typeof value !== "string" || value.trim().length === 0) throw new Error(`${path}.${key} must be a non-empty string`);
|
|
return value.trim();
|
|
}
|
|
|
|
function absolutePathField(record: Record<string, unknown>, key: string, path: string): string {
|
|
const value = stringField(record, key, path);
|
|
if (!value.startsWith("/")) throw new Error(`${path}.${key} must be an absolute path`);
|
|
return value.replace(/\/+$/u, "");
|
|
}
|
|
|
|
function positiveIntegerField(record: Record<string, unknown>, key: string, path: string): number {
|
|
const value = record[key];
|
|
if (!Number.isInteger(value) || Number(value) <= 0) throw new Error(`${path}.${key} must be a positive integer`);
|
|
return Number(value);
|
|
}
|
|
|
|
function portField(record: Record<string, unknown>, key: string, path: string): number {
|
|
const value = positiveIntegerField(record, key, path);
|
|
if (value > 65535) throw new Error(`${path}.${key} must be a TCP port`);
|
|
return value;
|
|
}
|