#!/usr/bin/env node
'use strict';

// ../u/leftpadesque/debug.ts
var _hasEnv = true;
var _env = _hasEnv && (process.env.ENVIRONMENT ?? '').toLowerCase().includes('prod') ? 'production' : 'development';
var isProd = () => _env === 'production';
var _debug = !isProd() || (_hasEnv && ['y', 't'].some((process.env.DEBUG ?? '').toLowerCase().startsWith));
var isDebug = () => _debug;

// ../u/leftpadesque/memoize.ts
var memoize = (fn) => {
    const cache = /* @__PURE__ */ new Map();
    return (...args) => {
        const key = JSON.stringify(args);
        if (cache.has(key)) {
            return cache.get(key);
        }
        const res = fn.apply(args);
        cache.set(key, res);
        return res;
    };
};

// ../u/trace/itrace.ts
var TraceableImpl = class _TraceableImpl {
    constructor(item, trace) {
        this.item = item;
        this.trace = trace;
    }
    map(mapper) {
        const result = mapper(this);
        return new _TraceableImpl(result, this.trace);
    }
    coExtend(mapper) {
        const results = mapper(this);
        return Array.from(results).map((result) => this.move(result));
    }
    flatMap(mapper) {
        return mapper(this);
    }
    flatMapAsync(mapper) {
        return new _TraceableImpl(
            mapper(this).then((t) => t.get()),
            this.trace,
        );
    }
    traceScope(mapper) {
        return new _TraceableImpl(this.get(), this.trace.traceScope(mapper(this)));
    }
    peek(peek) {
        peek(this);
        return this;
    }
    move(t) {
        return this.map(() => t);
    }
    bimap(mapper) {
        const { item, trace: _trace } = mapper(this);
        return this.move(item).traceScope(() => _trace);
    }
    get() {
        return this.item;
    }
};

// ../u/trace/metric/emittable.ts
var EmittableMetric = class {
    constructor(name, unit) {
        this.name = name;
        this.unit = unit;
    }
    withValue(value) {
        return {
            name: this.name,
            unit: this.unit,
            emissionTimestamp: Date.now(),
            value,
            _tag: MetricValueTag,
        };
    }
};

// ../u/trace/metric/metric.ts
var _Tagged = class {
    constructor(_tag = IMetricTag) {
        this._tag = _tag;
    }
};
var Metric = class _Metric extends _Tagged {
    constructor(
        name,
        parent = void 0,
        count = new EmittableMetric(_Metric.join(name, 'count'), 'COUNT' /* COUNT */),
        time = new EmittableMetric(_Metric.join(name, 'time'), 'MILLISECONDS' /* MILLISECONDS */),
    ) {
        super();
        this.name = name;
        this.parent = parent;
        this.count = count;
        this.time = time;
    }
    static DELIM = '.';
    child(_name) {
        const childName = _Metric.join(this.name, _name);
        return new _Metric(childName, this);
    }
    asResult() {
        return ResultMetric.from(this);
    }
    static join(...name) {
        return name.join(_Metric.DELIM);
    }
    static fromName(name) {
        return new _Metric(name);
    }
};
var ResultMetric = class _ResultMetric extends Metric {
    constructor(name, parent = void 0, failure, success, warn) {
        super(name, parent);
        this.name = name;
        this.parent = parent;
        this.failure = failure;
        this.success = success;
        this.warn = warn;
    }
    static from(metric) {
        const failure = metric.child('failure');
        const success = metric.child('success');
        const warn = metric.child('warn');
        return new _ResultMetric(metric.name, metric.parent, failure, success, warn);
    }
};

// ../u/trace/metric/trace.ts
var MetricsTrace = class _MetricsTrace {
    constructor(metricConsumer, activeTraces = /* @__PURE__ */ new Map(), completedTraces = /* @__PURE__ */ new Set()) {
        this.metricConsumer = metricConsumer;
        this.activeTraces = activeTraces;
        this.completedTraces = completedTraces;
    }
    traceScope(trace) {
        const now = Date.now();
        const metricsToTrace = (Array.isArray(trace) ? trace : [trace]).filter(isIMetric);
        const initialTraces = new Map(metricsToTrace.map((metric) => [metric, now]));
        return new _MetricsTrace(this.metricConsumer, initialTraces);
    }
    trace(metrics) {
        if (!metrics || typeof metrics === 'string') {
            return this;
        }
        const now = Date.now();
        const allMetrics = Array.isArray(metrics) ? metrics : [metrics];
        const valuesToEmit = allMetrics.filter(isMetricValue);
        const traceableMetrics = allMetrics.filter(isIMetric);
        const metricsToStart = traceableMetrics.filter((m) => !this.activeTraces.has(m));
        const metricsToEnd = traceableMetrics.filter((m) => this.activeTraces.has(m) && !this.completedTraces.has(m));
        const endedMetricValues = metricsToEnd.flatMap((metric) => [
            metric.count.withValue(1),
            metric.time.withValue(now - this.activeTraces.get(metric)),
        ]);
        const allMetricsToEmit = [...valuesToEmit, ...endedMetricValues];
        if (allMetricsToEmit.length > 0) {
            this.metricConsumer(allMetricsToEmit);
        }
        const nextActiveTraces = new Map([...this.activeTraces, ...metricsToStart.map((m) => [m, now])]);
        const nextCompletedTraces = /* @__PURE__ */ new Set([...this.completedTraces, ...metricsToEnd]);
        return new _MetricsTrace(this.metricConsumer, nextActiveTraces, nextCompletedTraces);
    }
};

// ../u/trace/metric/index.ts
var MetricValueTag = 'MetricValue';
var isMetricValue = (t) => isTagged(t, MetricValueTag);
var IMetricTag = 'IMetric';
var isIMetric = (t) => isTagged(t, IMetricTag);

// ../u/trace/log/ansi.ts
var ANSI = {
    RESET: '\x1B[0m',
    BOLD: '\x1B[1m',
    DIM: '\x1B[2m',
    RED: '\x1B[31m',
    GREEN: '\x1B[32m',
    YELLOW: '\x1B[33m',
    BLUE: '\x1B[34m',
    MAGENTA: '\x1B[35m',
    CYAN: '\x1B[36m',
    WHITE: '\x1B[37m',
    BRIGHT_RED: '\x1B[91m',
    BRIGHT_YELLOW: '\x1B[93m',
    GRAY: '\x1B[90m',
};

// ../u/trace/log/level.ts
var logLevelOrder = ['DEBUG' /* DEBUG */, 'INFO' /* INFO */, 'WARN' /* WARN */, 'ERROR' /* ERROR */, 'SYS' /* SYS */];
var isLogLevel = (l) => typeof l === 'string' && logLevelOrder.some((level) => level === l);

// ../u/trace/log/pretty_json_console.ts
var PrettyJsonConsoleLogger = class {
    log(level, ...trace) {
        const message = JSON.stringify(
            {
                level,
                trace,
            },
            null,
            4,
        );
        const styled = `${this.getStyle(level)}${message}${ANSI.RESET}
`;
        this.getStream(level)(styled);
    }
    getStream(level) {
        if (level === 'ERROR' /* ERROR */) {
            return console.error;
        }
        return console.log;
    }
    getStyle(level) {
        switch (level) {
            case 'UNKNOWN' /* UNKNOWN */:
            case 'INFO' /* INFO */:
                return `${ANSI.MAGENTA}`;
            case 'DEBUG' /* DEBUG */:
                return `${ANSI.CYAN}`;
            case 'WARN' /* WARN */:
                return `${ANSI.BRIGHT_YELLOW}`;
            case 'ERROR' /* ERROR */:
                return `${ANSI.BRIGHT_RED}`;
            case 'SYS' /* SYS */:
                return `${ANSI.DIM}${ANSI.BLUE}`;
        }
    }
};

// ../u/trace/log/trace.ts
var LogTrace = class _LogTrace {
    constructor(
        logger = new PrettyJsonConsoleLogger(),
        traces = [defaultTrace],
        defaultLevel = 'INFO' /* INFO */,
        allowedLevels = defaultAllowedLevelsSupplier,
    ) {
        this.logger = logger;
        this.traces = traces;
        this.defaultLevel = defaultLevel;
        this.allowedLevels = allowedLevels;
    }
    traceScope(trace) {
        return new _LogTrace(this.logger, this.traces.concat(trace), this.defaultLevel, this.allowedLevels);
    }
    trace(trace) {
        const { traces, level: _level } = this.foldTraces(this.traces.concat(trace));
        if (!this.allowedLevels().has(_level)) return;
        const level = _level === 'UNKNOWN' /* UNKNOWN */ ? this.defaultLevel : _level;
        this.logger.log(level, ...traces);
    }
    foldTraces(_traces) {
        const _logTraces = _traces.map((trace) => (typeof trace === 'function' ? trace() : trace));
        const _level = _logTraces
            .filter((trace) => isLogLevel(trace))
            .reduce((acc, level2) => Math.max(logLevelOrder.indexOf(level2), acc), -1);
        const level = logLevelOrder[_level] ?? 'UNKNOWN'; /* UNKNOWN */
        const traces = _logTraces
            .filter((trace) => !isLogLevel(trace))
            .map((trace) => {
                if (typeof trace === 'object') {
                    return `TracedException.Name = ${trace.name}, TracedException.Message = ${trace.message}, TracedException.Stack = ${trace.stack}`;
                }
                return trace;
            });
        return {
            level,
            traces,
        };
    }
};
var defaultTrace = () => `TimeStamp = ${/* @__PURE__ */ new Date().toISOString()}`;
var defaultAllowedLevels = memoize(
    (isDebug2) =>
        /* @__PURE__ */ new Set([
            'UNKNOWN' /* UNKNOWN */,
            ...(isDebug2 ? ['DEBUG' /* DEBUG */] : []),
            'INFO' /* INFO */,
            'WARN' /* WARN */,
            'ERROR' /* ERROR */,
            'SYS' /* SYS */,
        ]),
);
var defaultAllowedLevelsSupplier = () => defaultAllowedLevels(isDebug());

// ../u/trace/trace.ts
var LogTraceable = class _LogTraceable extends TraceableImpl {
    static LogTrace = new LogTrace();
    static of(t) {
        return new _LogTraceable(t, _LogTraceable.LogTrace);
    }
};
var getEmbeddedMetricConsumer = (logTrace) => (metrics) => {
    if (metrics.length === 0) return;
    logTrace.traceScope('SYS' /* SYS */).trace(`Metrics = <metrics>${JSON.stringify(metrics)}</metrics>`);
};
var EmbeddedMetricsTraceable = class _EmbeddedMetricsTraceable extends TraceableImpl {
    static MetricsTrace = new MetricsTrace(getEmbeddedMetricConsumer(LogTraceable.LogTrace));
    static of(t, metricsTrace = _EmbeddedMetricsTraceable.MetricsTrace) {
        return new _EmbeddedMetricsTraceable(t, metricsTrace);
    }
};

// ../u/process/exec.ts
var import_node_util = require('node:util');
var import_node_child_process = require('node:child_process');
var exec = (0, import_node_util.promisify)(import_node_child_process.exec);
var CmdMetric = Metric.fromName('Exec').asResult();

// ../u/process/signals.ts
var SigIntMetric = Metric.fromName('SigInt').asResult();
var SigTermMetric = Metric.fromName('SigTerm').asResult();

// ../u/server/response/pengueno.ts
var ResponseCodeMetrics = [0, 1, 2, 3, 4, 5].map((x) => Metric.fromName(`response.${x}xx`).asResult());

// ../u/server/activity/health.ts
var healthCheckMetric = Metric.fromName('Health').asResult();

// ../u/server/filter/json.ts
var ParseJsonMetric = Metric.fromName('JsonParse').asResult();

// ../u/server/filter/index.ts
var ErrorSource = ((ErrorSource2) => {
    ErrorSource2[(ErrorSource2['USER'] = 'WARN') /* WARN */] = 'USER';
    ErrorSource2[(ErrorSource2['SYSTEM'] = 'ERROR') /* ERROR */] = 'SYSTEM';
    return ErrorSource2;
})(ErrorSource || {});

// ../u/types/object.ts
var isObject = (o) => typeof o === 'object' && !Array.isArray(o) && !!o;

// ../u/types/tagged.ts
var isTagged = (o, tag) => !!(isObject(o) && '_tag' in o && o._tag === tag);

// ../u/types/fn/either.ts
var IEitherTag = 'IEither';
var ELeftTag = 'E.Left';
var isLeft = (o) => isTagged(o, ELeftTag);
var ERightTag = 'E.Right';
var isRight = (o) => isTagged(o, ERightTag);
var _Tagged2 = class {
    constructor(_tag = IEitherTag) {
        this._tag = _tag;
    }
};
var Either = class _Either extends _Tagged2 {
    constructor(self) {
        super();
        this.self = self;
    }
    moveRight(t) {
        return this.mapRight(() => t);
    }
    mapBoth(errBranch, okBranch) {
        if (isLeft(this.self)) return _Either.left(errBranch(this.self.err));
        return _Either.right(okBranch(this.self.ok));
    }
    mapRight(mapper) {
        if (isRight(this.self)) return _Either.right(mapper(this.self.ok));
        return _Either.left(this.self.err);
    }
    mapLeft(mapper) {
        if (isLeft(this.self)) return _Either.left(mapper(this.self.err));
        return _Either.right(this.self.ok);
    }
    flatMap(mapper) {
        if (isRight(this.self)) return mapper(this.self.ok);
        return _Either.left(this.self.err);
    }
    filter(mapper) {
        if (isLeft(this.self)) return _Either.left(this.self.err);
        return _Either.fromFailable(() => this.right().filter(mapper).get());
    }
    async flatMapAsync(mapper) {
        if (isLeft(this.self)) return Promise.resolve(_Either.left(this.self.err));
        return await mapper(this.self.ok).catch((err) => _Either.left(err));
    }
    fold(leftFolder, rightFolder) {
        if (isLeft(this.self)) return leftFolder(this.self.err);
        return rightFolder(this.self.ok);
    }
    left() {
        if (isLeft(this.self)) return Optional.from(this.self.err);
        return Optional.none();
    }
    right() {
        if (isRight(this.self)) return Optional.from(this.self.ok);
        return Optional.none();
    }
    joinRight(other, mapper) {
        return this.flatMap((t) => other.mapRight((o) => mapper(o, t)));
    }
    joinRightAsync(other, mapper) {
        return this.flatMapAsync(async (t) => {
            const o = typeof other === 'function' ? other() : other;
            return o.then((other2) => other2.mapRight((o2) => mapper(o2, t)));
        });
    }
    static left(e) {
        return new _Either({ err: e, _tag: ELeftTag });
    }
    static right(t) {
        return new _Either({ ok: t, _tag: ERightTag });
    }
    static fromFailable(s) {
        try {
            return _Either.right(s());
        } catch (e) {
            return _Either.left(e);
        }
    }
    static async fromFailableAsync(s) {
        return await (typeof s === 'function' ? s() : s).then((t) => _Either.right(t)).catch((e) => _Either.left(e));
    }
};

// ../u/types/fn/optional.ts
var IOptionalTag = 'IOptional';
var IOptionalEmptyError = class extends Error {};
var OSomeTag = 'O.Some';
var ONoneTag = 'O.None';
var isNone = (o) => isTagged(o, ONoneTag);
var isSome = (o) => isTagged(o, OSomeTag);
var _Tagged3 = class {
    constructor(_tag = IOptionalTag) {
        this._tag = _tag;
    }
};
var Optional = class _Optional extends _Tagged3 {
    constructor(self) {
        super();
        this.self = self;
    }
    move(t) {
        return this.map(() => t);
    }
    orSome(supplier) {
        if (isNone(this.self)) return _Optional.from(supplier());
        return this;
    }
    get() {
        if (isNone(this.self)) throw new IOptionalEmptyError('called get() on None optional');
        return this.self.value;
    }
    filter(mapper) {
        if (isNone(this.self) || !mapper(this.self.value)) return _Optional.none();
        return _Optional.some(this.self.value);
    }
    map(mapper) {
        if (isNone(this.self)) return _Optional.none();
        return _Optional.from(mapper(this.self.value));
    }
    flatMap(mapper) {
        if (isNone(this.self)) return _Optional.none();
        return _Optional
            .from(mapper(this.self.value))
            .orSome(() => _Optional.none())
            .get();
    }
    present() {
        return isSome(this.self);
    }
    *[Symbol.iterator]() {
        if (isSome(this.self)) yield this.self.value;
    }
    static some(value) {
        return new _Optional({ value, _tag: OSomeTag });
    }
    static _none = new _Optional({ _tag: ONoneTag });
    static none() {
        return this._none;
    }
    static from(value) {
        if (value === null || value === void 0) return _Optional.none();
        return _Optional.some(value);
    }
};

// ../model/job/index.ts
var isJob = (j) =>
    !!(isObject(j) && 'arguments' in j && isObject(j.arguments) && 'type' in j && typeof j.type === 'string' && j);

// ../model/pipeline/builder.ts
var BasePipelineBuilder = class {
    stages = [];
    addStage(stage) {
        this.stages.push(stage);
        return this;
    }
    build() {
        return new PipelineImpl(this.stages);
    }
};
var DefaultGitHookPipelineBuilder = class extends BasePipelineBuilder {
    constructor(remoteUrl = process.env.remote, rev = process.env.rev, refname = process.env.refname) {
        super();
        this.remoteUrl = remoteUrl;
        this.refname = refname;
        this.addStage({
            parallelJobs: [
                {
                    type: 'fetch_code',
                    arguments: {
                        remoteUrl,
                        checkout: rev,
                        path: this.getSourceDestination(),
                    },
                },
            ],
        });
    }
    getSourceDestination() {
        return this.remoteUrl.split('/').at(-1) ?? 'src';
    }
    getBranch() {
        const branchRefPrefix = 'refs/heads/';
        return this.refname.split(branchRefPrefix).at(1);
    }
};

// ../model/pipeline/impl.ts
var PipelineImpl = class _PipelineImpl {
    constructor(serialJobs) {
        this.serialJobs = serialJobs;
    }
    serialize() {
        return JSON.stringify({ serialJobs: this.serialJobs });
    }
    static from(s) {
        return Either.fromFailable(() => JSON.parse(s))
            .flatMap((eitherPipelineJson) =>
                isPipeline(eitherPipelineJson)
                    ? Either.right(eitherPipelineJson)
                    : Either.left(new Error('oh noes D: its a bad pipewine :((')),
            )
            .mapRight((pipeline) => new _PipelineImpl(pipeline.serialJobs));
    }
};

// ../model/pipeline/index.ts
var isPipelineStage = (t) =>
    isObject(t) && 'parallelJobs' in t && Array.isArray(t.parallelJobs) && t.parallelJobs.every((j) => isJob(j));
var isPipeline = (t) =>
    isObject(t) && 'serialJobs' in t && Array.isArray(t.serialJobs) && t.serialJobs.every((p) => isPipelineStage(p));

// dist/ci.js
var REGISTRY = 'oci.liz.coffee';
var NAMESPACE = 'emprespresso';
var IMG = 'ci';
var REMOTE = 'ssh://src.liz.coffee:2222';
var getPipeline = () => {
    const gitHookPipeline = new DefaultGitHookPipelineBuilder();
    const branch = gitHookPipeline.getBranch();
    if (!branch) return gitHookPipeline.build();
    const commonBuildArgs = {
        registry: REGISTRY,
        namespace: NAMESPACE,
        imageTag: branch,
    };
    const baseCiPackageBuild = {
        type: 'build_docker_image.js',
        arguments: {
            ...commonBuildArgs,
            context: gitHookPipeline.getSourceDestination(),
            repository: IMG + '_base',
            buildTarget: IMG + '_base',
            dockerfile: 'Dockerfile',
        },
    };
    gitHookPipeline.addStage({
        parallelJobs: [baseCiPackageBuild],
    });
    const subPackages = ['worker', 'hooks'].map((_package) => ({
        type: 'build_docker_image.js',
        arguments: {
            ...commonBuildArgs,
            repository: `${IMG}_${_package}`,
            buildTarget: _package,
            dockerfile: `${_package}/Dockerfile`,
        },
    }));
    gitHookPipeline.addStage({
        parallelJobs: subPackages,
    });
    const isRelease = branch === 'release';
    if (!isRelease) {
        return gitHookPipeline.build();
    }
    const fetchAnsibleCode = {
        type: 'fetch_code',
        arguments: {
            remoteUrl: `${REMOTE}/infra`,
            checkout: 'main',
            path: 'infra',
        },
    };
    const thenDeploy = {
        type: 'ansible_playbook.js',
        arguments: {
            path: 'infra',
            playbooks: 'playbooks/ci.yml',
        },
    };
    [fetchAnsibleCode, thenDeploy].forEach((deploymentStage) =>
        gitHookPipeline.addStage({ parallelJobs: [deploymentStage] }),
    );
    return gitHookPipeline.build();
};
var main = () => {
    const data = getPipeline().serialize();
    process.stdout.write(data);
};
main();