"use strict";
var __addDisposableResource = (this && this.__addDisposableResource) || function (env, value, async) {
    if (value !== null && value !== void 0) {
        if (typeof value !== "object" && typeof value !== "function") throw new TypeError("Object expected.");
        var dispose, inner;
        if (async) {
            if (!Symbol.asyncDispose) throw new TypeError("Symbol.asyncDispose is not defined.");
            dispose = value[Symbol.asyncDispose];
        }
        if (dispose === void 0) {
            if (!Symbol.dispose) throw new TypeError("Symbol.dispose is not defined.");
            dispose = value[Symbol.dispose];
            if (async) inner = dispose;
        }
        if (typeof dispose !== "function") throw new TypeError("Object not disposable.");
        if (inner) dispose = function() { try { inner.call(this); } catch (e) { return Promise.reject(e); } };
        env.stack.push({ value: value, dispose: dispose, async: async });
    }
    else if (async) {
        env.stack.push({ async: true });
    }
    return value;
};
var __disposeResources = (this && this.__disposeResources) || (function (SuppressedError) {
    return function (env) {
        function fail(e) {
            env.error = env.hasError ? new SuppressedError(e, env.error, "An error was suppressed during disposal.") : e;
            env.hasError = true;
        }
        var r, s = 0;
        function next() {
            while (r = env.stack.pop()) {
                try {
                    if (!r.async && s === 1) return s = 0, env.stack.push(r), Promise.resolve().then(next);
                    if (r.dispose) {
                        var result = r.dispose.call(r.value);
                        if (r.async) return s |= 2, Promise.resolve(result).then(next, function(e) { fail(e); return next(); });
                    }
                    else s |= 1;
                }
                catch (e) {
                    fail(e);
                }
            }
            if (s === 1) return env.hasError ? Promise.reject(env.error) : Promise.resolve();
            if (env.hasError) throw env.error;
        }
        return next();
    };
})(typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
    var e = new Error(message);
    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
});
Object.defineProperty(exports, "__esModule", { value: true });
exports.autoCleanDir = autoCleanDir;
/**
 * Legacy vs compatibility endpoint
 * ==================================
 *
 * This script talks about legacy vs compatibility endpoint a bunch.
 *
 * Both implement the Nexus 2 protocol, however:
 *
 * - The "legacy" endpoint is the Sonatype OSSRH endpoint that was deprecated June 2025.
 * - The "compatibility" endpoint is a Nexus 2-compatible endpoint stood up for the new
 *   publishing service, Central Publishing.
 *
 * It should be the same protocol but of course there are subtle differences
 * between them (in how they signal error when you try to republish an already
 * published version, and even in the wire protocol accepted) so we have to
 * treat them differently here.
 *
 * There is also an "official new" protocol for the new publishing mechanism,
 * but the Maven plugin they supply for that doesn't support that. In their words:
 *
 * > it appears that you are using the "two stage"[1] deployment process, which is
 * > not yet supported by the new plugin. You are the first publisher to have
 * > requested this, so we were not familiar with this specific usecase when
 * > building the new plugin
 * > [1] <https://github.com/sonatype/nexus-maven-plugins/blob/43a9940b134c3f87ebe4daa82552e844d9c578b8/staging/maven-plugin/WORKFLOWS.md#two-shots>
 */
const fs_1 = require("fs");
const zx_1 = require("zx");
const LEGACY_OSSRH_SERVER_ID = 'ossrh';
const COMPAT_CENTRAL_SERVER_ID = 'central-ossrh';
const NEXUS_MAVEN_STAGING_PLUGIN = 'org.sonatype.plugins:nexus-staging-maven-plugin:1.7.0';
async function main() {
    const args = process.argv.slice(2);
    const javaRoot = args[0] ?? 'dist/java';
    (0, zx_1.cd)(javaRoot);
    const poms = await (0, zx_1.glob)('**/*.pom');
    if (poms.length === 0) {
        throw new SimpleError(`No JARS to publish: no .pom files found under ${process.cwd()}`);
    }
    (0, zx_1.echo)(`POMs found: ${poms}`);
    const sharedOptions = {
        username: envVar('MAVEN_USERNAME'),
        password: envVar('MAVEN_PASSWORD'),
        dryRun: process.env.MAVEN_DRYRUN === 'true',
        verbose: process.env.MAVEN_VERBOSE === 'true',
        poms,
    };
    let options;
    const serverId = process.env.MAVEN_SERVER_ID ?? LEGACY_OSSRH_SERVER_ID;
    switch (serverId) {
        case LEGACY_OSSRH_SERVER_ID:
            options = {
                type: 'legacy-ossrh',
                ...sharedOptions,
                stagingProfileId: envVar('MAVEN_STAGING_PROFILE_ID'),
                endpoint: process.env.MAVEN_ENDPOINT,
                privateKey: parsePrivateKeyFromEnv(),
            };
            break;
        case COMPAT_CENTRAL_SERVER_ID:
            options = {
                type: 'compat-ossrh',
                ...sharedOptions,
                // Not required by the new endpoint: can be any value (maybe never was required to begin with?)
                stagingProfileId: 'publib',
                endpoint: process.env.MAVEN_ENDPOINT,
                privateKey: parsePrivateKeyFromEnv(),
            };
            break;
        default:
            // We haven't implemented signing for this, so fail loudly if people try to use it anyway
            if (process.env.MAVEN_GPG_PRIVATE_KEY || process.env.MAVEN_GPG_PRIVATE_KEY_FILE) {
                throw new SimpleError('MAVEN_GPG_PRIVATE_KEY[_FILE] is only supported for OSSRH publishing');
            }
            options = {
                type: 'custom-nexus',
                ...sharedOptions,
                serverId,
                repositoryUrl: envVar('MAVEN_REPOSITORY_URL'),
            };
            break;
    }
    await mavenPublish(options);
    (0, zx_1.echo)('~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~');
    (0, zx_1.echo)('✅ All Done!');
}
function parsePrivateKeyFromEnv() {
    if (process.env.MAVEN_GPG_PRIVATE_KEY_FILE) {
        return { type: 'file', fileName: process.env.MAVEN_GPG_PRIVATE_KEY_FILE, passPhrase: envVar('MAVEN_GPG_PRIVATE_KEY_PASSPHRASE') };
    }
    if (process.env.MAVEN_GPG_PRIVATE_KEY) {
        return { type: 'material', keyMaterial: process.env.MAVEN_GPG_PRIVATE_KEY, passPhrase: envVar('MAVEN_GPG_PRIVATE_KEY_PASSPHRASE') };
    }
    throw new SimpleError('MAVEN_GPG_PRIVATE_KEY[_FILE] is required');
}
//----------------------------------------------------------------------
//  Publishing functions
//
async function mavenPublish(options) {
    const env_1 = { stack: [], error: void 0, hasError: false };
    try {
        const workDir = __addDisposableResource(env_1, autoCleanDir(), true);
        const maven = new Maven(workDir.dir, options.verbose, options.dryRun);
        const x = options.type;
        switch (x) {
            case 'legacy-ossrh':
                await deployLegacyOssrh(maven, options);
                break;
            case 'compat-ossrh':
                await deployCompatOssrh(maven, options);
                break;
            case 'custom-nexus':
                await deployCustomNexus(maven, options);
                break;
            default:
                assertNever(x);
        }
    }
    catch (e_1) {
        env_1.error = e_1;
        env_1.hasError = true;
    }
    finally {
        const result_1 = __disposeResources(env_1);
        if (result_1)
            await result_1;
    }
}
/**
 * Deploy to the legacy OSSRH Nexus server
 */
async function deployLegacyOssrh(maven, options) {
    (0, zx_1.echo)('📦 Publishing to Maven Central');
    const defaultEndpoint = 'https://oss.sonatype.org';
    const staged = await deployStagedRepository(maven, {
        ...options,
        endpoint: options.endpoint ?? defaultEndpoint,
        republishWill400: false,
    });
    if (staged.type !== 'success') {
        return;
    }
    /*
    const released = await releaseRepo({
      serverUrl: options.endpoint ?? defaultEndpoint,
      username: options.username,
      password: options.password,
      repositoryId: staged.repositoryId,
    });
  
    if (released) {
      return;
    }
    */
    // Send a remote release command to the repository
    const releaseOutput = await maven.exec(`${NEXUS_MAVEN_STAGING_PLUGIN}:rc-release`, {
        properties: {
            nexusUrl: options.endpoint ?? defaultEndpoint,
            serverId: staged.serverId,
            stagingRepositoryId: staged.repositoryId,
        },
        nothrow: true,
    });
    if (!releaseOutput) {
        (0, zx_1.echo)('🏜️ Stopped here because of dry-run');
        return;
    }
    if (releaseOutput.exitCode !== 0) {
        // If release failed, check if this was caused because we are trying to publish
        // the same version again, which is not an error. The magic string "does not
        // allow updating artifact" for a ".pom" file indicates that we are trying to
        // override an existing version. Otherwise, fail!
        const looksLikeDuplicatePublish = releaseOutput.lines()
            .filter(l => l.includes('does not allow updating artifact'))
            .filter(l => l.includes('.pom'))
            .length > 0;
        if (!looksLikeDuplicatePublish) {
            throw new SimpleError('Release failed');
        }
        (0, zx_1.echo)('⚠️ Artifact already published. Skipping');
    }
}
/**
 * Deploy to the compat OSSRH Nexus server
 */
async function deployCompatOssrh(maven, options) {
    (0, zx_1.echo)('📦 Publishing to Maven Central (Compat endpoint)');
    const defaultEndpoint = 'https://ossrh-staging-api.central.sonatype.com/';
    const endpoint = options.endpoint ?? defaultEndpoint;
    const staged = await deployStagedRepository(maven, {
        ...options,
        endpoint,
        republishWill400: true,
    });
    if (staged.type !== 'success') {
        return;
    }
    const released = await releaseRepo({
        serverUrl: endpoint,
        username: options.username,
        password: options.password,
        repositoryId: staged.repositoryId,
    });
    if (released === 'duplicate-version') {
        (0, zx_1.echo)('⚠️ Version(s) already published. Skipping');
    }
}
/**
 * Deploy to a custom Nexus server
 */
async function deployCustomNexus(maven, options) {
    (0, zx_1.echo)(`📦 Publishing to ${options.serverId}`);
    await maven.writeSettingsFile(options.serverId, false);
    for (const pom of options.poms) {
        const deployOutput = await maven.exec('deploy:deploy-file', {
            properties: {
                url: options.repositoryUrl,
                repositoryId: options.serverId,
                pomFile: pom,
                ...jarsFromPom(pom),
            },
            nothrow: true,
        });
        if (deployOutput?.exitCode && deployOutput.exitCode > 0) {
            if (deployOutput.stdout.includes('409 Conflict')) {
                (0, zx_1.echo)('⚠️ Artifact already published. Skipping');
            }
            else {
                throw new SimpleError('Release failed');
            }
        }
    }
}
/**
 * Create the staging repository. This is the same between the legacy and compat endpoints.
 *
 * `republishWill400`: in the compatibility endpoint, staging a version that has already
 * been published will lead to a `400 Bad Request`, with no further info. We needed to have
 * run the Maven command with `--debug` logging to see the actual error message in the output.
 *
 * In the legacy endpoint, staging takes multiple minutes, and Maven will poll
 * every 3s and print the output. We therefore don't use verbose mode to avoid
 * stdout spam. In the legacy endpoint, duplicate version publishing gets
 * reported during the 'release' step anyway, not during staging.
 */
async function deployStagedRepository(maven, options) {
    const serverId = 'ossrh';
    await maven.writeSettingsFile(serverId, true);
    // First -- sign artifacts
    const signedDir = zx_1.path.join(maven.workDir, 'signed');
    await fs_1.promises.mkdir(signedDir, { recursive: true });
    await signJars(maven, options.poms, signedDir, serverId, options.privateKey);
    (0, zx_1.echo)('~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~');
    (0, zx_1.echo)(' Deploying and closing repository...');
    (0, zx_1.echo)('~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~');
    const nexusMavenStaging = 'org.sonatype.plugins:nexus-staging-maven-plugin:1.7.0';
    const stageOutput = await maven.exec(`${nexusMavenStaging}:deploy-staged-repository`, {
        properties: {
            repositoryDirectory: signedDir,
            nexusUrl: options.endpoint,
            serverId,
            stagingProgressTimeoutMinutes: '30',
            stagingProfileId: options.stagingProfileId,
        },
        nothrow: true,
        verbose: options.republishWill400,
    });
    // FIXME: New staging API throws an error here on duplicate versions
    if (stageOutput === undefined) {
        (0, zx_1.echo)('🏜️ Stopped here because of dry-run');
        return { type: 'dry-run' };
    }
    if (options.republishWill400 && stageOutput.text().match(/Component with package url.*already exists/)) {
        // We've seen this fail with the above error message on the OSSRH compatibility API when trying to republish
        // an already-published version.
        //
        // This is potentially a problem if there are multiple versions in the source directory at once, because nothing
        // will be published if there's one package in there that has already been published previously. But c'est la vie.
        (0, zx_1.echo)('⚠️ Version(s) already published. Skipping');
        return { type: 'already-published' };
    }
    else if (stageOutput.exitCode && stageOutput.exitCode > 0) {
        throw stageOutput;
    }
    // Grep the repository ID out of the printed output
    // [INFO]  * Closing staging repository with ID "XXXXXXXXXX".
    const m = stageOutput.stdout.match(/Closing staging repository with ID "([^"]+)"/);
    if (!m) {
        throw new SimpleError('Unable to extract repository ID from deploy-staged-repository output. This means it failed to close or there was an unexpected problem. At any rate, we can\'t release it. Sorry.');
    }
    const repositoryId = m[1];
    return { type: 'success', repositoryId, serverId };
}
/**
 * Send a custom "release" command to the new Sonatype backwards compatibility endpoint
 *
 * When using the `nexus-staging-maven-plugin`'s `release` or `rc-release` commands, we get the following
 * error:
 *
 * Sending:
 *
 * ```
 * <stagingActionRequest><data><stagedRepositoryIds class="java.util.Arrays$ArrayList"><a class="string-array"><string>io.github.rix0rrr--63edbcbe-f058-44eb-85f4-fd9dce1aef40</string></a></stagedRepositoryIds><description>unknown</description><autoDropAfterRelease>true</autoDropAfterRelease></data></stagingActionRequest>
 * ```
 *
 * Error:
 *
 * ```
 * Failed to process request: Got unexpected XML element when reading stagedRepositoryIds: Got unexpected element StartElement(a, {"": "", "xml": "http://www.w3.org/XML/1998/namespace", "xmlns": "http://www.w3.org/2000/xmlns/"}, [class -> string-array]), expected one of: string
 * ```
 *
 * Doing a manual slightly modified version of the above request succeeds, so we'll just proceed with doing
 * that.
 *
 * The endpoint also supports JSON, which we prefer over XML.
 *
 * This endpoint will never return an error, even if the publish didn't happen because
 * of duplicate version publishing (not for the legacy, nor for the compatibility endpoint).
 *
 * @see https://central.sonatype.org/publish/publish-portal-ossrh-staging-api/
 * @see https://support.sonatype.com/hc/en-us/articles/213465448-Automatically-dropping-old-staging-repositories
 */
async function releaseRepo(options) {
    (0, zx_1.echo)(`🚀 Releasing repository ${options.repositoryId} at ${options.serverUrl}`);
    const url = new URL('service/local/staging/bulk/promote', options.serverUrl);
    const response = await fetch(url, {
        method: 'POST',
        body: JSON.stringify({
            data: {
                stagedRepositoryIds: [options.repositoryId],
                description: options.description ?? 'Deployment',
                autoDropAfterRelease: true,
            },
        }),
        headers: {
            'Content-Type': 'application/json',
            'Accept': 'application/json',
            'Authorization': `Basic ${btoa(`${options.username}:${options.password}`)}`,
        },
    });
    const body = await response.text();
    // It's possible that (due to some replication latency?) the initial "stage" succeeds,
    // but the "release" fails, if we try to publish an already-published version again.
    //
    // Unfortunately there is no great error code to detect this right now, but I've observed
    // this error when it happened.
    // I have a support request out to Sonatype for this, we'll see if this changes over time.
    if (response.status === 400 && body === 'Failed to process request: service error') {
        return 'duplicate-version';
    }
    if (!response.ok) {
        throw new Error(`HTTP ${response.status} ${response.statusText}: ${body}`);
    }
    console.log(body);
    return 'ok';
}
/**
 * Sign and stage our artifacts into a local directory
 */
async function signJars(maven, poms, targetDir, serverId, key) {
    const env_2 = { stack: [], error: void 0, hasError: false };
    try {
        const gpg = __addDisposableResource(env_2, await importGpgKey(key), true);
        // on a mac, --pinentry-mode to "loopback" are required and I couldn't find a
        // way to do so via -Dgpg.gpgArguments or the settings file, so here we are.
        let gpgBin = 'gpg';
        if (zx_1.os.platform() === 'darwin') {
            gpgBin = zx_1.path.join(maven.workDir, 'publib-gpg.sh');
            await fs_1.promises.writeFile(gpgBin, [
                '#!/bin/bash',
                'exec gpg --pinentry-mode loopback "\$@"',
            ].join('\n'), 'utf-8');
            await (0, zx_1.$) `chmod +x ${gpgBin}`;
        }
        for (const pom of poms) {
            await maven.exec('gpg:sign-and-deploy-file', {
                properties: {
                    'url': `file://${targetDir}`,
                    'repositoryId': serverId, // Most likely not necessary
                    'gpg.homedir': gpg.home,
                    'gpg.keyname': gpg.keyId,
                    'gpg.executable': gpgBin,
                    'pomFile': pom,
                    ...jarsFromPom(pom),
                },
            });
        }
    }
    catch (e_2) {
        env_2.error = e_2;
        env_2.hasError = true;
    }
    finally {
        const result_2 = __disposeResources(env_2);
        if (result_2)
            await result_2;
    }
}
/**
 * Based on the path of a .pom file, return the paths of the corresponding jars
 */
function jarsFromPom(pom) {
    return {
        file: pom.replace(/\.pom$/, '.jar'),
        sources: pom.replace(/\.pom$/, '-sources.jar'),
        javadoc: pom.replace(/\.pom$/, '-javadoc.jar'),
    };
}
/**
 * Create a temporary directory and import the GPG key material into a new keychain there
 */
async function importGpgKey(key) {
    // GnuPG will occasionally bail out with "gpg: <whatever> failed: Inappropriate ioctl for device", the following attempts to fix
    const gpgHome = autoCleanDir();
    try {
        // In CI environments there will be no tty, and we don't want this to stop the script.
        // The variable will be populated with a nonsensical string ("not a tty") but that doesn't seem to matter.
        const tty = (await (0, zx_1.$)({ stdio: ['inherit', 'pipe', 'pipe'], nothrow: true }) `tty`).stdout;
        let privateKeyFile;
        const type = key.type;
        switch (type) {
            case 'file':
                privateKeyFile = key.fileName;
                break;
            case 'material':
                privateKeyFile = zx_1.path.join(gpgHome.dir, 'private.pem');
                await (0, zx_1.$) `echo -e ${key.keyMaterial} > ${privateKeyFile}`;
                break;
            default:
                assertNever(type);
        }
        const env = {
            GNUPGHOME: gpgHome.dir,
            GPG_TTY: tty,
        };
        const $$ = (0, zx_1.$)({ env: { ...process.env, ...env } });
        await $$ `gpg --allow-secret-key-import --batch --yes --no-tty --import ${privateKeyFile}`;
        const gpgKeyId = (await $$ `gpg --list-keys --with-colons | grep pub | cut -d: -f5`).stdout.trim();
        (0, zx_1.echo)(`gpg_key_id=${gpgKeyId}`);
        return {
            keyId: gpgKeyId,
            env,
            home: gpgHome.dir,
            [Symbol.asyncDispose]: async () => gpgHome[Symbol.asyncDispose](),
        };
    }
    catch (e) {
        await gpgHome[Symbol.asyncDispose]();
        throw e;
    }
}
class Maven {
    constructor(workDir, verbose, dryRun) {
        this.workDir = workDir;
        this.verbose = verbose;
        this.dryRun = dryRun;
        this.settingsFile = zx_1.path.join(workDir, 'mvn-settings.xml');
    }
    /**
     * Create a settings.xml file with the user+password for maven
     */
    async writeSettingsFile(serverId, signedArtifacts) {
        const lines = [];
        lines.push('<?xml version="1.0" encoding="UTF-8" ?>', '<settings xmlns="http://maven.apache.org/SETTINGS/1.0.0"', '        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"', '        xsi:schemaLocation="http://maven.apache.org/SETTINGS/1.0.0', '                            http://maven.apache.org/xsd/settings-1.0.0.xsd">', '  <servers>', '    <server>', `      <id>${serverId}</id>`, 
        // Maven will read these, surrounding code has already made sure they are set
        '      <username>${env.MAVEN_USERNAME}</username>', '      <password>${env.MAVEN_PASSWORD}</password>', '    </server>');
        if (signedArtifacts) {
            lines.push('    <server>', '      <id>gpg.passphrase</id>', 
            // Maven will read these, surrounding code has already made sure they are set
            '      <passphrase>${env.MAVEN_GPG_PRIVATE_KEY_PASSPHRASE}</passphrase>', '    </server>');
        }
        lines.push('  </servers>', '</settings>');
        await fs_1.promises.writeFile(this.settingsFile, lines.join('\n'), 'utf-8');
    }
    async exec(mojo, options) {
        const args = [
            `--settings=${this.settingsFile}`,
            '--batch-mode',
            ...(options.verbose ?? this.verbose ? ['-X'] : []),
            mojo,
            ...Object.entries(options.properties).map(([k, v]) => `-D${k}=${v}`),
        ];
        if (this.dryRun) {
            (0, zx_1.echo)(`[DRY-RUN] mvn ${args.map(zx_1.quote).join(' ')}`);
            return undefined;
        }
        const env = {
            ...process.env,
            JDK_JAVA_OPTIONS: [
                // If we don't add this, we'll get an error like the following during the nexus-staging-maven-plugin:rc-release mojo.
                // Don't know where this is coming from all of a sudden.
                //
                // [ERROR] message             : No converter available
                // [ERROR] type                : java.util.Arrays$ArrayList
                // [ERROR] converter           : com.thoughtworks.xstream.converters.reflection.ReflectionConverter
                // [ERROR] message[1]          : Unable to make field protected transient int java.util.AbstractList.modCount accessible: module java.base does not "opens java.util" to unnamed module @7c8d5312
                '--add-opens=java.base/java.util=ALL-UNNAMED',
                '--add-opens=java.base/java.lang=ALL-UNNAMED',
                '--add-opens=java.base/java.lang.invoke=ALL-UNNAMED',
            ].join(' '),
        };
        return (0, zx_1.$)({ verbose: true, nothrow: options.nothrow, env }) `mvn ${args}`;
    }
}
/**
 * A expected error that doesn't need a stack trace
 */
class SimpleError extends Error {
}
/**
 * Require an environment variable
 */
function envVar(name) {
    const ret = process.env[name];
    if (!ret) {
        throw new SimpleError(`${name} is required`);
    }
    return ret;
}
/**
 * A temporary directory that cleans when it goes out of scope
 *
 * Use with `using`. Could have been async but it's depending
 * on an already-sync API, so why not sync?
 */
function autoCleanDir() {
    const dir = (0, zx_1.tmpdir)();
    return {
        dir,
        [Symbol.asyncDispose]: async () => {
            await fs_1.promises.rm(dir, { force: true, recursive: true });
        },
    };
}
function assertNever(value) {
    throw new Error('Unexpected value: ' + value);
}
// A 'zx' primer
//
// - By default: stderr is printed to the terminal if it is captured.
// - { verbose: true }: print the command, stdout and stderr to the terminal
// - { quiet: true }: print neither stdout nor stderr
//
// .text(): return everything that's captured (stderr and stdout together if stderr is captured)
main().catch(e => {
    if (e instanceof zx_1.ProcessOutput) {
        (0, zx_1.echo)(`❌ Subprocess failed with exit code ${e.exitCode}`);
    }
    else if (e instanceof SimpleError) {
        (0, zx_1.echo)('❌', e.message);
    }
    else {
        console.error(e);
    }
    process.exitCode = 1;
});
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"publib-maven.js","sourceRoot":"","sources":["../../src/bin/publib-maven.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA6nBA,oCAQC;AAroBD;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,2BAAoC;AACpC,2BAA+E;AAE/E,MAAM,sBAAsB,GAAG,OAAO,CAAC;AACvC,MAAM,wBAAwB,GAAG,eAAe,CAAC;AAEjD,MAAM,0BAA0B,GAAG,uDAAuD,CAAC;AAE3F,KAAK,UAAU,IAAI;IACjB,MAAM,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;IACnC,MAAM,QAAQ,GAAG,IAAI,CAAC,CAAC,CAAC,IAAI,WAAW,CAAC;IAExC,IAAA,OAAE,EAAC,QAAQ,CAAC,CAAC;IAEb,MAAM,IAAI,GAAG,MAAM,IAAA,SAAI,EAAC,UAAU,CAAC,CAAC;IACpC,IAAI,IAAI,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;QACtB,MAAM,IAAI,WAAW,CAAC,iDAAiD,OAAO,CAAC,GAAG,EAAE,EAAE,CAAC,CAAC;IAC1F,CAAC;IAED,IAAA,SAAI,EAAC,eAAe,IAAI,EAAE,CAAC,CAAC;IAE5B,MAAM,aAAa,GAAyB;QAC1C,QAAQ,EAAE,MAAM,CAAC,gBAAgB,CAAC;QAClC,QAAQ,EAAE,MAAM,CAAC,gBAAgB,CAAC;QAClC,MAAM,EAAE,OAAO,CAAC,GAAG,CAAC,YAAY,KAAK,MAAM;QAC3C,OAAO,EAAE,OAAO,CAAC,GAAG,CAAC,aAAa,KAAK,MAAM;QAC7C,IAAI;KACL,CAAC;IAEF,IAAI,OAA4B,CAAC;IACjC,MAAM,QAAQ,GAAG,OAAO,CAAC,GAAG,CAAC,eAAe,IAAI,sBAAsB,CAAC;IAEvE,QAAQ,QAAQ,EAAE,CAAC;QACjB,KAAK,sBAAsB;YACzB,OAAO,GAAG;gBACR,IAAI,EAAE,cAAc;gBACpB,GAAG,aAAa;gBAChB,gBAAgB,EAAE,MAAM,CAAC,0BAA0B,CAAC;gBACpD,QAAQ,EAAE,OAAO,CAAC,GAAG,CAAC,cAAc;gBACpC,UAAU,EAAE,sBAAsB,EAAE;aACrC,CAAC;YACF,MAAM;QACR,KAAK,wBAAwB;YAC3B,OAAO,GAAG;gBACR,IAAI,EAAE,cAAc;gBACpB,GAAG,aAAa;gBAChB,+FAA+F;gBAC/F,gBAAgB,EAAE,QAAQ;gBAC1B,QAAQ,EAAE,OAAO,CAAC,GAAG,CAAC,cAAc;gBACpC,UAAU,EAAE,sBAAsB,EAAE;aACrC,CAAC;YACF,MAAM;QACR;YACE,yFAAyF;YACzF,IAAI,OAAO,CAAC,GAAG,CAAC,qBAAqB,IAAI,OAAO,CAAC,GAAG,CAAC,0BAA0B,EAAE,CAAC;gBAChF,MAAM,IAAI,WAAW,CAAC,qEAAqE,CAAC,CAAC;YAC/F,CAAC;YAED,OAAO,GAAG;gBACR,IAAI,EAAE,cAAc;gBACpB,GAAG,aAAa;gBAChB,QAAQ;gBACR,aAAa,EAAE,MAAM,CAAC,sBAAsB,CAAC;aAC9C,CAAC;YACF,MAAM;IACV,CAAC;IAED,MAAM,YAAY,CAAC,OAAO,CAAC,CAAC;IAE5B,IAAA,SAAI,EAAC,gGAAgG,CAAC,CAAC;IACvG,IAAA,SAAI,EAAC,aAAa,CAAC,CAAC;AACtB,CAAC;AAED,SAAS,sBAAsB;IAC7B,IAAI,OAAO,CAAC,GAAG,CAAC,0BAA0B,EAAE,CAAC;QAC3C,OAAO,EAAE,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,OAAO,CAAC,GAAG,CAAC,0BAA0B,EAAE,UAAU,EAAE,MAAM,CAAC,kCAAkC,CAAC,EAAE,CAAC;IACpI,CAAC;IACD,IAAI,OAAO,CAAC,GAAG,CAAC,qBAAqB,EAAE,CAAC;QACtC,OAAO,EAAE,IAAI,EAAE,UAAU,EAAE,WAAW,EAAE,OAAO,CAAC,GAAG,CAAC,qBAAqB,EAAE,UAAU,EAAE,MAAM,CAAC,kCAAkC,CAAC,EAAE,CAAC;IACtI,CAAC;IACD,MAAM,IAAI,WAAW,CAAC,0CAA0C,CAAC,CAAC;AACpE,CAAC;AAyCD,wEAAwE;AACxE,wBAAwB;AACxB,EAAE;AAEF,KAAK,UAAU,YAAY,CAAC,OAA4B;;;QACtD,MAAY,OAAO,kCAAG,YAAY,EAAE,OAAA,CAAC;QACrC,MAAM,KAAK,GAAG,IAAI,KAAK,CAAC,OAAO,CAAC,GAAG,EAAE,OAAO,CAAC,OAAO,EAAE,OAAO,CAAC,MAAM,CAAC,CAAC;QAEtE,MAAM,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC;QACvB,QAAQ,CAAC,EAAE,CAAC;YACV,KAAK,cAAc;gBACjB,MAAM,iBAAiB,CAAC,KAAK,EAAE,OAAO,CAAC,CAAC;gBACxC,MAAM;YACR,KAAK,cAAc;gBACjB,MAAM,iBAAiB,CAAC,KAAK,EAAE,OAAO,CAAC,CAAC;gBACxC,MAAM;YACR,KAAK,cAAc;gBACjB,MAAM,iBAAiB,CAAC,KAAK,EAAE,OAAO,CAAC,CAAC;gBACxC,MAAM;YACR;gBACE,WAAW,CAAC,CAAC,CAAC,CAAC;QACnB,CAAC;;;;;;;;;;;CACF;AAED;;GAEG;AACH,KAAK,UAAU,iBAAiB,CAAC,KAAY,EAAE,OAAkC;IAC/E,IAAA,SAAI,EAAC,gCAAgC,CAAC,CAAC;IACvC,MAAM,eAAe,GAAG,0BAA0B,CAAC;IAEnD,MAAM,MAAM,GAAG,MAAM,sBAAsB,CAAC,KAAK,EAAE;QACjD,GAAG,OAAO;QACV,QAAQ,EAAE,OAAO,CAAC,QAAQ,IAAI,eAAe;QAC7C,gBAAgB,EAAE,KAAK;KACxB,CAAC,CAAC;IAEH,IAAI,MAAM,CAAC,IAAI,KAAK,SAAS,EAAE,CAAC;QAC9B,OAAO;IACT,CAAC;IAED;;;;;;;;;;;MAWE;IAEF,kDAAkD;IAClD,MAAM,aAAa,GAAG,MAAM,KAAK,CAAC,IAAI,CAAC,GAAG,0BAA0B,aAAa,EAAE;QACjF,UAAU,EAAE;YACV,QAAQ,EAAE,OAAO,CAAC,QAAQ,IAAI,eAAe;YAC7C,QAAQ,EAAE,MAAM,CAAC,QAAQ;YACzB,mBAAmB,EAAE,MAAM,CAAC,YAAY;SACzC;QACD,OAAO,EAAE,IAAI;KACd,CAAC,CAAC;IACH,IAAI,CAAC,aAAa,EAAE,CAAC;QACnB,IAAA,SAAI,EAAC,qCAAqC,CAAC,CAAC;QAC5C,OAAO;IACT,CAAC;IAED,IAAI,aAAa,CAAC,QAAQ,KAAK,CAAC,EAAE,CAAC;QACjC,+EAA+E;QAC/E,4EAA4E;QAC5E,6EAA6E;QAC7E,iDAAiD;QAEjD,MAAM,yBAAyB,GAAG,aAAa,CAAC,KAAK,EAAE;aACpD,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,QAAQ,CAAC,kCAAkC,CAAC,CAAC;aAC3D,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAC;aAC/B,MAAM,GAAG,CAAC,CAAC;QAEd,IAAI,CAAC,yBAAyB,EAAE,CAAC;YAC/B,MAAM,IAAI,WAAW,CAAC,gBAAgB,CAAC,CAAC;QAC1C,CAAC;QAED,IAAA,SAAI,EAAC,yCAAyC,CAAC,CAAC;IAClD,CAAC;AACH,CAAC;AAED;;GAEG;AACH,KAAK,UAAU,iBAAiB,CAAC,KAAY,EAAE,OAAkC;IAC/E,IAAA,SAAI,EAAC,kDAAkD,CAAC,CAAC;IAEzD,MAAM,eAAe,GAAG,iDAAiD,CAAC;IAC1E,MAAM,QAAQ,GAAG,OAAO,CAAC,QAAQ,IAAI,eAAe,CAAC;IAErD,MAAM,MAAM,GAAG,MAAM,sBAAsB,CAAC,KAAK,EAAE;QACjD,GAAG,OAAO;QACV,QAAQ;QACR,gBAAgB,EAAE,IAAI;KACvB,CAAC,CAAC;IAEH,IAAI,MAAM,CAAC,IAAI,KAAK,SAAS,EAAE,CAAC;QAC9B,OAAO;IACT,CAAC;IAED,MAAM,QAAQ,GAAG,MAAM,WAAW,CAAC;QACjC,SAAS,EAAE,QAAQ;QACnB,QAAQ,EAAE,OAAO,CAAC,QAAQ;QAC1B,QAAQ,EAAE,OAAO,CAAC,QAAQ;QAC1B,YAAY,EAAE,MAAM,CAAC,YAAY;KAClC,CAAC,CAAC;IAEH,IAAI,QAAQ,KAAK,mBAAmB,EAAE,CAAC;QACrC,IAAA,SAAI,EAAC,2CAA2C,CAAC,CAAC;IACpD,CAAC;AACH,CAAC;AAED;;GAEG;AACH,KAAK,UAAU,iBAAiB,CAAC,KAAY,EAAE,OAAkC;IAC/E,IAAA,SAAI,EAAC,oBAAoB,OAAO,CAAC,QAAQ,EAAE,CAAC,CAAC;IAC7C,MAAM,KAAK,CAAC,iBAAiB,CAAC,OAAO,CAAC,QAAQ,EAAE,KAAK,CAAC,CAAC;IAEvD,KAAK,MAAM,GAAG,IAAI,OAAO,CAAC,IAAI,EAAE,CAAC;QAC/B,MAAM,YAAY,GAAG,MAAM,KAAK,CAAC,IAAI,CAAC,oBAAoB,EAAE;YAC1D,UAAU,EAAE;gBACV,GAAG,EAAE,OAAO,CAAC,aAAa;gBAC1B,YAAY,EAAE,OAAO,CAAC,QAAQ;gBAC9B,OAAO,EAAE,GAAG;gBACZ,GAAG,WAAW,CAAC,GAAG,CAAC;aACpB;YACD,OAAO,EAAE,IAAI;SACd,CAAC,CAAC;QAEH,IAAI,YAAY,EAAE,QAAQ,IAAI,YAAY,CAAC,QAAQ,GAAG,CAAC,EAAE,CAAC;YACxD,IAAI,YAAY,CAAC,MAAM,CAAC,QAAQ,CAAC,cAAc,CAAC,EAAE,CAAC;gBACjD,IAAA,SAAI,EAAC,yCAAyC,CAAC,CAAC;YAClD,CAAC;iBAAM,CAAC;gBACN,MAAM,IAAI,WAAW,CAAC,gBAAgB,CAAC,CAAC;YAC1C,CAAC;QACH,CAAC;IACH,CAAC;AACH,CAAC;AAOD;;;;;;;;;;;GAWG;AACH,KAAK,UAAU,sBAAsB,CAAC,KAAY,EAAE,OAAkI;IACpL,MAAM,QAAQ,GAAG,OAAO,CAAC;IAEzB,MAAM,KAAK,CAAC,iBAAiB,CAAC,QAAQ,EAAE,IAAI,CAAC,CAAC;IAE9C,0BAA0B;IAC1B,MAAM,SAAS,GAAG,SAAI,CAAC,IAAI,CAAC,KAAK,CAAC,OAAO,EAAE,QAAQ,CAAC,CAAC;IACrD,MAAM,aAAE,CAAC,KAAK,CAAC,SAAS,EAAE,EAAE,SAAS,EAAE,IAAI,EAAE,CAAC,CAAC;IAE/C,MAAM,QAAQ,CAAC,KAAK,EAAE,OAAO,CAAC,IAAI,EAAE,SAAS,EAAE,QAAQ,EAAE,OAAO,CAAC,UAAU,CAAC,CAAC;IAE7E,IAAA,SAAI,EAAC,gGAAgG,CAAC,CAAC;IACvG,IAAA,SAAI,EAAC,sCAAsC,CAAC,CAAC;IAC7C,IAAA,SAAI,EAAC,gGAAgG,CAAC,CAAC;IAEvG,MAAM,iBAAiB,GAAG,uDAAuD,CAAC;IAClF,MAAM,WAAW,GAAG,MAAM,KAAK,CAAC,IAAI,CAAC,GAAG,iBAAiB,2BAA2B,EAAE;QACpF,UAAU,EAAE;YACV,mBAAmB,EAAE,SAAS;YAC9B,QAAQ,EAAE,OAAO,CAAC,QAAQ;YAC1B,QAAQ;YACR,6BAA6B,EAAE,IAAI;YACnC,gBAAgB,EAAE,OAAO,CAAC,gBAAgB;SAC3C;QACD,OAAO,EAAE,IAAI;QACb,OAAO,EAAE,OAAO,CAAC,gBAAgB;KAClC,CAAC,CAAC;IACH,oEAAoE;IACpE,IAAI,WAAW,KAAK,SAAS,EAAE,CAAC;QAC9B,IAAA,SAAI,EAAC,qCAAqC,CAAC,CAAC;QAC5C,OAAO,EAAE,IAAI,EAAE,SAAS,EAAE,CAAC;IAC7B,CAAC;IAED,IAAI,OAAO,CAAC,gBAAgB,IAAI,WAAW,CAAC,IAAI,EAAE,CAAC,KAAK,CAAC,4CAA4C,CAAC,EAAE,CAAC;QACvG,4GAA4G;QAC5G,gCAAgC;QAChC,EAAE;QACF,gHAAgH;QAChH,kHAAkH;QAClH,IAAA,SAAI,EAAC,2CAA2C,CAAC,CAAC;QAClD,OAAO,EAAE,IAAI,EAAE,mBAAmB,EAAE,CAAC;IACvC,CAAC;SAAM,IAAI,WAAW,CAAC,QAAQ,IAAI,WAAW,CAAC,QAAQ,GAAG,CAAC,EAAE,CAAC;QAC5D,MAAM,WAAW,CAAC;IACpB,CAAC;IAED,mDAAmD;IACnD,6DAA6D;IAC7D,MAAM,CAAC,GAAG,WAAW,CAAC,MAAM,CAAC,KAAK,CAAC,8CAA8C,CAAC,CAAC;IACnF,IAAI,CAAC,CAAC,EAAE,CAAC;QACP,MAAM,IAAI,WAAW,CAAC,mLAAmL,CAAC,CAAC;IAC7M,CAAC;IACD,MAAM,YAAY,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC;IAE1B,OAAO,EAAE,IAAI,EAAE,SAAS,EAAE,YAAY,EAAE,QAAQ,EAAE,CAAC;AACrD,CAAC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,KAAK,UAAU,WAAW,CAAC,OAA8G;IACvI,IAAA,SAAI,EAAC,2BAA2B,OAAO,CAAC,YAAY,OAAO,OAAO,CAAC,SAAS,EAAE,CAAC,CAAC;IAChF,MAAM,GAAG,GAAG,IAAI,GAAG,CAAC,oCAAoC,EAAE,OAAO,CAAC,SAAS,CAAC,CAAC;IAE7E,MAAM,QAAQ,GAAG,MAAM,KAAK,CAAC,GAAG,EAAE;QAChC,MAAM,EAAE,MAAM;QACd,IAAI,EAAE,IAAI,CAAC,SAAS,CAAC;YACnB,IAAI,EAAE;gBACJ,mBAAmB,EAAE,CAAC,OAAO,CAAC,YAAY,CAAC;gBAC3C,WAAW,EAAE,OAAO,CAAC,WAAW,IAAI,YAAY;gBAChD,oBAAoB,EAAE,IAAI;aAC3B;SACF,CAAC;QACF,OAAO,EAAE;YACP,cAAc,EAAE,kBAAkB;YAClC,QAAQ,EAAE,kBAAkB;YAC5B,eAAe,EAAE,SAAS,IAAI,CAAC,GAAG,OAAO,CAAC,QAAQ,IAAI,OAAO,CAAC,QAAQ,EAAE,CAAC,EAAE;SAC5E;KACF,CAAC,CAAC;IAEH,MAAM,IAAI,GAAG,MAAM,QAAQ,CAAC,IAAI,EAAE,CAAC;IAEnC,sFAAsF;IACtF,oFAAoF;IACpF,EAAE;IACF,yFAAyF;IACzF,+BAA+B;IAC/B,0FAA0F;IAC1F,IAAI,QAAQ,CAAC,MAAM,KAAK,GAAG,IAAI,IAAI,KAAK,0CAA0C,EAAE,CAAC;QACnF,OAAO,mBAAmB,CAAC;IAC7B,CAAC;IAED,IAAI,CAAC,QAAQ,CAAC,EAAE,EAAE,CAAC;QACjB,MAAM,IAAI,KAAK,CAAC,QAAQ,QAAQ,CAAC,MAAM,IAAI,QAAQ,CAAC,UAAU,KAAK,IAAI,EAAE,CAAC,CAAC;IAC7E,CAAC;IAED,OAAO,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;IAElB,OAAO,IAAI,CAAC;AACd,CAAC;AAED;;GAEG;AACH,KAAK,UAAU,QAAQ,CAAC,KAAY,EAAE,IAAc,EAAE,SAAiB,EAAE,QAAgB,EAAE,GAAe;;;QACxG,MAAY,GAAG,kCAAG,MAAM,YAAY,CAAC,GAAG,CAAC,OAAA,CAAC;QAE1C,6EAA6E;QAC7E,4EAA4E;QAC5E,IAAI,MAAM,GAAG,KAAK,CAAC;QACnB,IAAI,OAAE,CAAC,QAAQ,EAAE,KAAK,QAAQ,EAAE,CAAC;YAC/B,MAAM,GAAG,SAAI,CAAC,IAAI,CAAC,KAAK,CAAC,OAAO,EAAE,eAAe,CAAC,CAAC;YACnD,MAAM,aAAE,CAAC,SAAS,CAAC,MAAM,EAAE;gBACzB,aAAa;gBACb,yCAAyC;aAC1C,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE,OAAO,CAAC,CAAC;YACvB,MAAM,IAAA,MAAC,EAAA,YAAY,MAAM,EAAE,CAAC;QAC9B,CAAC;QAED,KAAK,MAAM,GAAG,IAAI,IAAI,EAAE,CAAC;YACvB,MAAM,KAAK,CAAC,IAAI,CAAC,0BAA0B,EAAE;gBAC3C,UAAU,EAAE;oBACV,KAAK,EAAE,UAAU,SAAS,EAAE;oBAC5B,cAAc,EAAE,QAAQ,EAAE,4BAA4B;oBACtD,aAAa,EAAE,GAAG,CAAC,IAAI;oBACvB,aAAa,EAAE,GAAG,CAAC,KAAK;oBACxB,gBAAgB,EAAE,MAAM;oBACxB,SAAS,EAAE,GAAG;oBACd,GAAG,WAAW,CAAC,GAAG,CAAC;iBACpB;aACF,CAAC,CAAC;QACL,CAAC;;;;;;;;;;;CACF;AAED;;GAEG;AACH,SAAS,WAAW,CAAC,GAAW;IAC9B,OAAO;QACL,IAAI,EAAE,GAAG,CAAC,OAAO,CAAC,QAAQ,EAAE,MAAM,CAAC;QACnC,OAAO,EAAE,GAAG,CAAC,OAAO,CAAC,QAAQ,EAAE,cAAc,CAAC;QAC9C,OAAO,EAAE,GAAG,CAAC,OAAO,CAAC,QAAQ,EAAE,cAAc,CAAC;KAC/C,CAAC;AACJ,CAAC;AAED;;GAEG;AACH,KAAK,UAAU,YAAY,CAAC,GAAe;IACzC,gIAAgI;IAChI,MAAM,OAAO,GAAG,YAAY,EAAE,CAAC;IAC/B,IAAI,CAAC;QACH,sFAAsF;QACtF,0GAA0G;QAC1G,MAAM,GAAG,GAAG,CAAC,MAAM,IAAA,MAAC,EAAC,EAAE,KAAK,EAAE,CAAC,SAAS,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,OAAO,EAAE,IAAI,EAAE,CAAC,CAAA,KAAK,CAAC,CAAC,MAAM,CAAC;QAEzF,IAAI,cAAc,CAAC;QACnB,MAAM,IAAI,GAAG,GAAG,CAAC,IAAI,CAAC;QACtB,QAAQ,IAAI,EAAE,CAAC;YACb,KAAK,MAAM;gBACT,cAAc,GAAG,GAAG,CAAC,QAAQ,CAAC;gBAC9B,MAAM;YACR,KAAK,UAAU;gBACb,cAAc,GAAG,SAAI,CAAC,IAAI,CAAC,OAAO,CAAC,GAAG,EAAE,aAAa,CAAC,CAAC;gBACvD,MAAM,IAAA,MAAC,EAAA,WAAW,GAAG,CAAC,WAAW,MAAM,cAAc,EAAE,CAAC;gBACxD,MAAM;YACR;gBACE,WAAW,CAAC,IAAI,CAAC,CAAC;QACtB,CAAC;QAED,MAAM,GAAG,GAAG;YACV,SAAS,EAAE,OAAO,CAAC,GAAG;YACtB,OAAO,EAAE,GAAG;SACb,CAAC;QAEF,MAAM,EAAE,GAAG,IAAA,MAAC,EAAC,EAAE,GAAG,EAAE,EAAE,GAAG,OAAO,CAAC,GAAG,EAAE,GAAG,GAAG,EAAE,EAAE,CAAC,CAAC;QAElD,MAAM,EAAE,CAAA,iEAAiE,cAAc,EAAE,CAAC;QAC1F,MAAM,QAAQ,GAAG,CAAC,MAAM,EAAE,CAAA,wDAAwD,CAAC,CAAC,MAAM,CAAC,IAAI,EAAE,CAAC;QAElG,IAAA,SAAI,EAAC,cAAc,QAAQ,EAAE,CAAC,CAAC;QAE/B,OAAO;YACL,KAAK,EAAE,QAAQ;YACf,GAAG;YACH,IAAI,EAAE,OAAO,CAAC,GAAG;YACjB,CAAC,MAAM,CAAC,YAAY,CAAC,EAAE,KAAK,IAAI,EAAE,CAAC,OAAO,CAAC,MAAM,CAAC,YAAY,CAAC,EAAE;SAClE,CAAC;IACJ,CAAC;IAAC,OAAO,CAAC,EAAE,CAAC;QACX,MAAM,OAAO,CAAC,MAAM,CAAC,YAAY,CAAC,EAAE,CAAC;QACrC,MAAM,CAAC,CAAC;IACV,CAAC;AACH,CAAC;AAED,MAAM,KAAK;IAGT,YAA4B,OAAe,EAAmB,OAAgB,EAAkB,MAAe;QAAnF,YAAO,GAAP,OAAO,CAAQ;QAAmB,YAAO,GAAP,OAAO,CAAS;QAAkB,WAAM,GAAN,MAAM,CAAS;QAC7G,IAAI,CAAC,YAAY,GAAG,SAAI,CAAC,IAAI,CAAC,OAAO,EAAE,kBAAkB,CAAC,CAAC;IAC7D,CAAC;IAED;;OAEG;IACI,KAAK,CAAC,iBAAiB,CAAC,QAAgB,EAAE,eAAwB;QACvE,MAAM,KAAK,GAAG,EAAE,CAAC;QAEjB,KAAK,CAAC,IAAI,CACR,yCAAyC,EACzC,0DAA0D,EAC1D,+DAA+D,EAC/D,oEAAoE,EACpE,8EAA8E,EAC9E,aAAa,EACb,cAAc,EACd,aAAa,QAAQ,OAAO;QAC5B,6EAA6E;QAC7E,kDAAkD,EAClD,kDAAkD,EAClD,eAAe,CAChB,CAAC;QAEF,IAAI,eAAe,EAAE,CAAC;YACpB,KAAK,CAAC,IAAI,CACR,cAAc,EACd,+BAA+B;YAC/B,6EAA6E;YAC7E,wEAAwE,EACxE,eAAe,CAChB,CAAC;QACJ,CAAC;QAED,KAAK,CAAC,IAAI,CACR,cAAc,EACd,aAAa,CACd,CAAC;QAEF,MAAM,aAAE,CAAC,SAAS,CAAC,IAAI,CAAC,YAAY,EAAE,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE,OAAO,CAAC,CAAC;IACnE,CAAC;IAEM,KAAK,CAAC,IAAI,CAAC,IAAY,EAAE,OAAyB;QACvD,MAAM,IAAI,GAAG;YACX,cAAc,IAAI,CAAC,YAAY,EAAE;YACjC,cAAc;YACd,GAAG,CAAC,OAAO,CAAC,OAAO,IAAI,IAAI,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC;YAClD,IAAI;YACJ,GAAG,MAAM,CAAC,OAAO,CAAC,OAAO,CAAC,UAAU,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,EAAE,EAAE,CAAC,KAAK,CAAC,IAAI,CAAC,EAAE,CAAC;SACrE,CAAC;QAEF,IAAI,IAAI,CAAC,MAAM,EAAE,CAAC;YAChB,IAAA,SAAI,EAAC,iBAAiB,IAAI,CAAC,GAAG,CAAC,UAAK,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC;YACnD,OAAO,SAAS,CAAC;QACnB,CAAC;QACD,MAAM,GAAG,GAAG;YACV,GAAG,OAAO,CAAC,GAAG;YACd,gBAAgB,EAAE;gBAChB,qHAAqH;gBACrH,wDAAwD;gBACxD,EAAE;gBACF,uDAAuD;gBACvD,2DAA2D;gBAC3D,mGAAmG;gBACnG,iMAAiM;gBACjM,6CAA6C;gBAC7C,6CAA6C;gBAC7C,oDAAoD;aACrD,CAAC,IAAI,CAAC,GAAG,CAAC;SACZ,CAAC;QAEF,OAAO,IAAA,MAAC,EAAC,EAAE,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,OAAO,CAAC,OAAO,EAAE,GAAG,EAAE,CAAC,CAAA,OAAO,IAAI,EAAE,CAAC;IAC1E,CAAC;CACF;AAQD;;GAEG;AACH,MAAM,WAAY,SAAQ,KAAK;CAAI;AAEnC;;GAEG;AACH,SAAS,MAAM,CAAC,IAAY;IAC1B,MAAM,GAAG,GAAG,OAAO,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;IAC9B,IAAI,CAAC,GAAG,EAAE,CAAC;QACT,MAAM,IAAI,WAAW,CAAC,GAAG,IAAI,cAAc,CAAC,CAAC;IAC/C,CAAC;IACD,OAAO,GAAG,CAAC;AACb,CAAC;AAED;;;;;GAKG;AACH,SAAgB,YAAY;IAC1B,MAAM,GAAG,GAAG,IAAA,WAAM,GAAE,CAAC;IACrB,OAAO;QACL,GAAG;QACH,CAAC,MAAM,CAAC,YAAY,CAAC,EAAE,KAAK,IAAI,EAAE;YAChC,MAAM,aAAE,CAAC,EAAE,CAAC,GAAG,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,SAAS,EAAE,IAAI,EAAE,CAAC,CAAC;QACrD,CAAC;KACF,CAAC;AACJ,CAAC;AAED,SAAS,WAAW,CAAC,KAAY;IAC/B,MAAM,IAAI,KAAK,CAAC,oBAAoB,GAAG,KAAK,CAAC,CAAC;AAChD,CAAC;AAED,gBAAgB;AAChB,EAAE;AACF,qEAAqE;AACrE,4EAA4E;AAC5E,qDAAqD;AACrD,EAAE;AACF,gGAAgG;AAEhG,IAAI,EAAE,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE;IACf,IAAI,CAAC,YAAY,kBAAa,EAAE,CAAC;QAC/B,IAAA,SAAI,EAAC,sCAAsC,CAAC,CAAC,QAAQ,EAAE,CAAC,CAAC;IAC3D,CAAC;SAAM,IAAI,CAAC,YAAY,WAAW,EAAE,CAAC;QACpC,IAAA,SAAI,EAAC,GAAG,EAAE,CAAC,CAAC,OAAO,CAAC,CAAC;IACvB,CAAC;SAAM,CAAC;QACN,OAAO,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;IACnB,CAAC;IACD,OAAO,CAAC,QAAQ,GAAG,CAAC,CAAC;AACvB,CAAC,CAAC,CAAC","sourcesContent":["/**\n * Legacy vs compatibility endpoint\n * ==================================\n *\n * This script talks about legacy vs compatibility endpoint a bunch.\n *\n * Both implement the Nexus 2 protocol, however:\n *\n * - The \"legacy\" endpoint is the Sonatype OSSRH endpoint that was deprecated June 2025.\n * - The \"compatibility\" endpoint is a Nexus 2-compatible endpoint stood up for the new\n *   publishing service, Central Publishing.\n *\n * It should be the same protocol but of course there are subtle differences\n * between them (in how they signal error when you try to republish an already\n * published version, and even in the wire protocol accepted) so we have to\n * treat them differently here.\n *\n * There is also an \"official new\" protocol for the new publishing mechanism,\n * but the Maven plugin they supply for that doesn't support that. In their words:\n *\n * > it appears that you are using the \"two stage\"[1] deployment process, which is\n * > not yet supported by the new plugin. You are the first publisher to have\n * > requested this, so we were not familiar with this specific usecase when\n * > building the new plugin\n * > [1] <https://github.com/sonatype/nexus-maven-plugins/blob/43a9940b134c3f87ebe4daa82552e844d9c578b8/staging/maven-plugin/WORKFLOWS.md#two-shots>\n */\nimport { promises as fs } from 'fs';\nimport { $, cd, echo, glob, os, path, ProcessOutput, quote, tmpdir } from 'zx';\n\nconst LEGACY_OSSRH_SERVER_ID = 'ossrh';\nconst COMPAT_CENTRAL_SERVER_ID = 'central-ossrh';\n\nconst NEXUS_MAVEN_STAGING_PLUGIN = 'org.sonatype.plugins:nexus-staging-maven-plugin:1.7.0';\n\nasync function main() {\n  const args = process.argv.slice(2);\n  const javaRoot = args[0] ?? 'dist/java';\n\n  cd(javaRoot);\n\n  const poms = await glob('**/*.pom');\n  if (poms.length === 0) {\n    throw new SimpleError(`No JARS to publish: no .pom files found under ${process.cwd()}`);\n  }\n\n  echo(`POMs found: ${poms}`);\n\n  const sharedOptions: SharedPublishOptions = {\n    username: envVar('MAVEN_USERNAME'),\n    password: envVar('MAVEN_PASSWORD'),\n    dryRun: process.env.MAVEN_DRYRUN === 'true',\n    verbose: process.env.MAVEN_VERBOSE === 'true',\n    poms,\n  };\n\n  let options: MavenPublishOptions;\n  const serverId = process.env.MAVEN_SERVER_ID ?? LEGACY_OSSRH_SERVER_ID;\n\n  switch (serverId) {\n    case LEGACY_OSSRH_SERVER_ID:\n      options = {\n        type: 'legacy-ossrh',\n        ...sharedOptions,\n        stagingProfileId: envVar('MAVEN_STAGING_PROFILE_ID'),\n        endpoint: process.env.MAVEN_ENDPOINT,\n        privateKey: parsePrivateKeyFromEnv(),\n      };\n      break;\n    case COMPAT_CENTRAL_SERVER_ID:\n      options = {\n        type: 'compat-ossrh',\n        ...sharedOptions,\n        // Not required by the new endpoint: can be any value (maybe never was required to begin with?)\n        stagingProfileId: 'publib',\n        endpoint: process.env.MAVEN_ENDPOINT,\n        privateKey: parsePrivateKeyFromEnv(),\n      };\n      break;\n    default:\n      // We haven't implemented signing for this, so fail loudly if people try to use it anyway\n      if (process.env.MAVEN_GPG_PRIVATE_KEY || process.env.MAVEN_GPG_PRIVATE_KEY_FILE) {\n        throw new SimpleError('MAVEN_GPG_PRIVATE_KEY[_FILE] is only supported for OSSRH publishing');\n      }\n\n      options = {\n        type: 'custom-nexus',\n        ...sharedOptions,\n        serverId,\n        repositoryUrl: envVar('MAVEN_REPOSITORY_URL'),\n      };\n      break;\n  }\n\n  await mavenPublish(options);\n\n  echo('~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~');\n  echo('✅ All Done!');\n}\n\nfunction parsePrivateKeyFromEnv(): PrivateKey {\n  if (process.env.MAVEN_GPG_PRIVATE_KEY_FILE) {\n    return { type: 'file', fileName: process.env.MAVEN_GPG_PRIVATE_KEY_FILE, passPhrase: envVar('MAVEN_GPG_PRIVATE_KEY_PASSPHRASE') };\n  }\n  if (process.env.MAVEN_GPG_PRIVATE_KEY) {\n    return { type: 'material', keyMaterial: process.env.MAVEN_GPG_PRIVATE_KEY, passPhrase: envVar('MAVEN_GPG_PRIVATE_KEY_PASSPHRASE') };\n  }\n  throw new SimpleError('MAVEN_GPG_PRIVATE_KEY[_FILE] is required');\n}\n\n//----------------------------------------------------------------------\n//  Modeling all the parameters so that we can pull the environment parsing forward\n//\n\ninterface SharedPublishOptions {\n  readonly username: string;\n  readonly password: string;\n  readonly dryRun: boolean;\n  readonly verbose: boolean;\n  readonly poms: string[];\n}\n\ninterface LegacyOssrhPublishOptions extends SharedPublishOptions {\n  type: 'legacy-ossrh';\n  readonly privateKey: PrivateKey;\n  readonly endpoint?: string;\n  readonly stagingProfileId: string;\n}\n\ninterface CompatOssrhPublishOptions extends SharedPublishOptions {\n  type: 'compat-ossrh';\n  readonly privateKey: PrivateKey;\n  readonly endpoint?: string;\n  readonly stagingProfileId: string;\n}\n\ninterface CustomNexusPublishOptions extends SharedPublishOptions {\n  type: 'custom-nexus';\n  readonly repositoryUrl: string;\n  readonly serverId: string;\n}\n\ntype PrivateKey =\n  | { type: 'file'; fileName: string; passPhrase: string }\n  | { type: 'material'; keyMaterial: string; passPhrase: string }\n  ;\n\ntype MavenPublishOptions = LegacyOssrhPublishOptions | CompatOssrhPublishOptions| CustomNexusPublishOptions;\n\n//----------------------------------------------------------------------\n//  Publishing functions\n//\n\nasync function mavenPublish(options: MavenPublishOptions) {\n  await using workDir = autoCleanDir();\n  const maven = new Maven(workDir.dir, options.verbose, options.dryRun);\n\n  const x = options.type;\n  switch (x) {\n    case 'legacy-ossrh':\n      await deployLegacyOssrh(maven, options);\n      break;\n    case 'compat-ossrh':\n      await deployCompatOssrh(maven, options);\n      break;\n    case 'custom-nexus':\n      await deployCustomNexus(maven, options);\n      break;\n    default:\n      assertNever(x);\n  }\n}\n\n/**\n * Deploy to the legacy OSSRH Nexus server\n */\nasync function deployLegacyOssrh(maven: Maven, options: LegacyOssrhPublishOptions) {\n  echo('📦 Publishing to Maven Central');\n  const defaultEndpoint = 'https://oss.sonatype.org';\n\n  const staged = await deployStagedRepository(maven, {\n    ...options,\n    endpoint: options.endpoint ?? defaultEndpoint,\n    republishWill400: false,\n  });\n\n  if (staged.type !== 'success') {\n    return;\n  }\n\n  /*\n  const released = await releaseRepo({\n    serverUrl: options.endpoint ?? defaultEndpoint,\n    username: options.username,\n    password: options.password,\n    repositoryId: staged.repositoryId,\n  });\n\n  if (released) {\n    return;\n  }\n  */\n\n  // Send a remote release command to the repository\n  const releaseOutput = await maven.exec(`${NEXUS_MAVEN_STAGING_PLUGIN}:rc-release`, {\n    properties: {\n      nexusUrl: options.endpoint ?? defaultEndpoint,\n      serverId: staged.serverId,\n      stagingRepositoryId: staged.repositoryId,\n    },\n    nothrow: true,\n  });\n  if (!releaseOutput) {\n    echo('🏜️ Stopped here because of dry-run');\n    return;\n  }\n\n  if (releaseOutput.exitCode !== 0) {\n    // If release failed, check if this was caused because we are trying to publish\n    // the same version again, which is not an error. The magic string \"does not\n    // allow updating artifact\" for a \".pom\" file indicates that we are trying to\n    // override an existing version. Otherwise, fail!\n\n    const looksLikeDuplicatePublish = releaseOutput.lines()\n      .filter(l => l.includes('does not allow updating artifact'))\n      .filter(l => l.includes('.pom'))\n      .length > 0;\n\n    if (!looksLikeDuplicatePublish) {\n      throw new SimpleError('Release failed');\n    }\n\n    echo('⚠️ Artifact already published. Skipping');\n  }\n}\n\n/**\n * Deploy to the compat OSSRH Nexus server\n */\nasync function deployCompatOssrh(maven: Maven, options: CompatOssrhPublishOptions) {\n  echo('📦 Publishing to Maven Central (Compat endpoint)');\n\n  const defaultEndpoint = 'https://ossrh-staging-api.central.sonatype.com/';\n  const endpoint = options.endpoint ?? defaultEndpoint;\n\n  const staged = await deployStagedRepository(maven, {\n    ...options,\n    endpoint,\n    republishWill400: true,\n  });\n\n  if (staged.type !== 'success') {\n    return;\n  }\n\n  const released = await releaseRepo({\n    serverUrl: endpoint,\n    username: options.username,\n    password: options.password,\n    repositoryId: staged.repositoryId,\n  });\n\n  if (released === 'duplicate-version') {\n    echo('⚠️ Version(s) already published. Skipping');\n  }\n}\n\n/**\n * Deploy to a custom Nexus server\n */\nasync function deployCustomNexus(maven: Maven, options: CustomNexusPublishOptions) {\n  echo(`📦 Publishing to ${options.serverId}`);\n  await maven.writeSettingsFile(options.serverId, false);\n\n  for (const pom of options.poms) {\n    const deployOutput = await maven.exec('deploy:deploy-file', {\n      properties: {\n        url: options.repositoryUrl,\n        repositoryId: options.serverId,\n        pomFile: pom,\n        ...jarsFromPom(pom),\n      },\n      nothrow: true,\n    });\n\n    if (deployOutput?.exitCode && deployOutput.exitCode > 0) {\n      if (deployOutput.stdout.includes('409 Conflict')) {\n        echo('⚠️ Artifact already published. Skipping');\n      } else {\n        throw new SimpleError('Release failed');\n      }\n    }\n  }\n}\n\ntype DeployStagedRepoResult =\n  | { type: 'success'; repositoryId: string; serverId: string }\n  | { type: 'already-published' }\n  | { type: 'dry-run' };\n\n/**\n * Create the staging repository. This is the same between the legacy and compat endpoints.\n *\n * `republishWill400`: in the compatibility endpoint, staging a version that has already\n * been published will lead to a `400 Bad Request`, with no further info. We needed to have\n * run the Maven command with `--debug` logging to see the actual error message in the output.\n *\n * In the legacy endpoint, staging takes multiple minutes, and Maven will poll\n * every 3s and print the output. We therefore don't use verbose mode to avoid\n * stdout spam. In the legacy endpoint, duplicate version publishing gets\n * reported during the 'release' step anyway, not during staging.\n */\nasync function deployStagedRepository(maven: Maven, options: Omit<LegacyOssrhPublishOptions | CompatOssrhPublishOptions, 'endpoint'> & { endpoint: string; republishWill400: boolean }): Promise<DeployStagedRepoResult> {\n  const serverId = 'ossrh';\n\n  await maven.writeSettingsFile(serverId, true);\n\n  // First -- sign artifacts\n  const signedDir = path.join(maven.workDir, 'signed');\n  await fs.mkdir(signedDir, { recursive: true });\n\n  await signJars(maven, options.poms, signedDir, serverId, options.privateKey);\n\n  echo('~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~');\n  echo(' Deploying and closing repository...');\n  echo('~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~');\n\n  const nexusMavenStaging = 'org.sonatype.plugins:nexus-staging-maven-plugin:1.7.0';\n  const stageOutput = await maven.exec(`${nexusMavenStaging}:deploy-staged-repository`, {\n    properties: {\n      repositoryDirectory: signedDir,\n      nexusUrl: options.endpoint,\n      serverId,\n      stagingProgressTimeoutMinutes: '30',\n      stagingProfileId: options.stagingProfileId,\n    },\n    nothrow: true,\n    verbose: options.republishWill400,\n  });\n  // FIXME: New staging API throws an error here on duplicate versions\n  if (stageOutput === undefined) {\n    echo('🏜️ Stopped here because of dry-run');\n    return { type: 'dry-run' };\n  }\n\n  if (options.republishWill400 && stageOutput.text().match(/Component with package url.*already exists/)) {\n    // We've seen this fail with the above error message on the OSSRH compatibility API when trying to republish\n    // an already-published version.\n    //\n    // This is potentially a problem if there are multiple versions in the source directory at once, because nothing\n    // will be published if there's one package in there that has already been published previously. But c'est la vie.\n    echo('⚠️ Version(s) already published. Skipping');\n    return { type: 'already-published' };\n  } else if (stageOutput.exitCode && stageOutput.exitCode > 0) {\n    throw stageOutput;\n  }\n\n  // Grep the repository ID out of the printed output\n  // [INFO]  * Closing staging repository with ID \"XXXXXXXXXX\".\n  const m = stageOutput.stdout.match(/Closing staging repository with ID \"([^\"]+)\"/);\n  if (!m) {\n    throw new SimpleError('Unable to extract repository ID from deploy-staged-repository output. This means it failed to close or there was an unexpected problem. At any rate, we can\\'t release it. Sorry.');\n  }\n  const repositoryId = m[1];\n\n  return { type: 'success', repositoryId, serverId };\n}\n\n/**\n * Send a custom \"release\" command to the new Sonatype backwards compatibility endpoint\n *\n * When using the `nexus-staging-maven-plugin`'s `release` or `rc-release` commands, we get the following\n * error:\n *\n * Sending:\n *\n * ```\n * <stagingActionRequest><data><stagedRepositoryIds class=\"java.util.Arrays$ArrayList\"><a class=\"string-array\"><string>io.github.rix0rrr--63edbcbe-f058-44eb-85f4-fd9dce1aef40</string></a></stagedRepositoryIds><description>unknown</description><autoDropAfterRelease>true</autoDropAfterRelease></data></stagingActionRequest>\n * ```\n *\n * Error:\n *\n * ```\n * Failed to process request: Got unexpected XML element when reading stagedRepositoryIds: Got unexpected element StartElement(a, {\"\": \"\", \"xml\": \"http://www.w3.org/XML/1998/namespace\", \"xmlns\": \"http://www.w3.org/2000/xmlns/\"}, [class -> string-array]), expected one of: string\n * ```\n *\n * Doing a manual slightly modified version of the above request succeeds, so we'll just proceed with doing\n * that.\n *\n * The endpoint also supports JSON, which we prefer over XML.\n *\n * This endpoint will never return an error, even if the publish didn't happen because\n * of duplicate version publishing (not for the legacy, nor for the compatibility endpoint).\n *\n * @see https://central.sonatype.org/publish/publish-portal-ossrh-staging-api/\n * @see https://support.sonatype.com/hc/en-us/articles/213465448-Automatically-dropping-old-staging-repositories\n */\nasync function releaseRepo(options: { serverUrl: string; username: string; password: string; repositoryId: string; description?: string }): Promise<'ok' | 'duplicate-version'> {\n  echo(`🚀 Releasing repository ${options.repositoryId} at ${options.serverUrl}`);\n  const url = new URL('service/local/staging/bulk/promote', options.serverUrl);\n\n  const response = await fetch(url, {\n    method: 'POST',\n    body: JSON.stringify({\n      data: {\n        stagedRepositoryIds: [options.repositoryId],\n        description: options.description ?? 'Deployment',\n        autoDropAfterRelease: true,\n      },\n    }),\n    headers: {\n      'Content-Type': 'application/json',\n      'Accept': 'application/json',\n      'Authorization': `Basic ${btoa(`${options.username}:${options.password}`)}`,\n    },\n  });\n\n  const body = await response.text();\n\n  // It's possible that (due to some replication latency?) the initial \"stage\" succeeds,\n  // but the \"release\" fails, if we try to publish an already-published version again.\n  //\n  // Unfortunately there is no great error code to detect this right now, but I've observed\n  // this error when it happened.\n  // I have a support request out to Sonatype for this, we'll see if this changes over time.\n  if (response.status === 400 && body === 'Failed to process request: service error') {\n    return 'duplicate-version';\n  }\n\n  if (!response.ok) {\n    throw new Error(`HTTP ${response.status} ${response.statusText}: ${body}`);\n  }\n\n  console.log(body);\n\n  return 'ok';\n}\n\n/**\n * Sign and stage our artifacts into a local directory\n */\nasync function signJars(maven: Maven, poms: string[], targetDir: string, serverId: string, key: PrivateKey) {\n  await using gpg = await importGpgKey(key);\n\n  // on a mac, --pinentry-mode to \"loopback\" are required and I couldn't find a\n  // way to do so via -Dgpg.gpgArguments or the settings file, so here we are.\n  let gpgBin = 'gpg';\n  if (os.platform() === 'darwin') {\n    gpgBin = path.join(maven.workDir, 'publib-gpg.sh');\n    await fs.writeFile(gpgBin, [\n      '#!/bin/bash',\n      'exec gpg --pinentry-mode loopback \"\\$@\"',\n    ].join('\\n'), 'utf-8');\n    await $`chmod +x ${gpgBin}`;\n  }\n\n  for (const pom of poms) {\n    await maven.exec('gpg:sign-and-deploy-file', {\n      properties: {\n        'url': `file://${targetDir}`,\n        'repositoryId': serverId, // Most likely not necessary\n        'gpg.homedir': gpg.home,\n        'gpg.keyname': gpg.keyId,\n        'gpg.executable': gpgBin,\n        'pomFile': pom,\n        ...jarsFromPom(pom),\n      },\n    });\n  }\n}\n\n/**\n * Based on the path of a .pom file, return the paths of the corresponding jars\n */\nfunction jarsFromPom(pom: string) {\n  return {\n    file: pom.replace(/\\.pom$/, '.jar'),\n    sources: pom.replace(/\\.pom$/, '-sources.jar'),\n    javadoc: pom.replace(/\\.pom$/, '-javadoc.jar'),\n  };\n}\n\n/**\n * Create a temporary directory and import the GPG key material into a new keychain there\n */\nasync function importGpgKey(key: PrivateKey) {\n  // GnuPG will occasionally bail out with \"gpg: <whatever> failed: Inappropriate ioctl for device\", the following attempts to fix\n  const gpgHome = autoCleanDir();\n  try {\n    // In CI environments there will be no tty, and we don't want this to stop the script.\n    // The variable will be populated with a nonsensical string (\"not a tty\") but that doesn't seem to matter.\n    const tty = (await $({ stdio: ['inherit', 'pipe', 'pipe'], nothrow: true })`tty`).stdout;\n\n    let privateKeyFile;\n    const type = key.type;\n    switch (type) {\n      case 'file':\n        privateKeyFile = key.fileName;\n        break;\n      case 'material':\n        privateKeyFile = path.join(gpgHome.dir, 'private.pem');\n        await $`echo -e ${key.keyMaterial} > ${privateKeyFile}`;\n        break;\n      default:\n        assertNever(type);\n    }\n\n    const env = {\n      GNUPGHOME: gpgHome.dir,\n      GPG_TTY: tty,\n    };\n\n    const $$ = $({ env: { ...process.env, ...env } });\n\n    await $$`gpg --allow-secret-key-import --batch --yes --no-tty --import ${privateKeyFile}`;\n    const gpgKeyId = (await $$`gpg --list-keys --with-colons | grep pub | cut -d: -f5`).stdout.trim();\n\n    echo(`gpg_key_id=${gpgKeyId}`);\n\n    return {\n      keyId: gpgKeyId,\n      env,\n      home: gpgHome.dir,\n      [Symbol.asyncDispose]: async () => gpgHome[Symbol.asyncDispose](),\n    };\n  } catch (e) {\n    await gpgHome[Symbol.asyncDispose]();\n    throw e;\n  }\n}\n\nclass Maven {\n  private readonly settingsFile: string;\n\n  constructor(public readonly workDir: string, private readonly verbose: boolean, public readonly dryRun: boolean) {\n    this.settingsFile = path.join(workDir, 'mvn-settings.xml');\n  }\n\n  /**\n   * Create a settings.xml file with the user+password for maven\n   */\n  public async writeSettingsFile(serverId: string, signedArtifacts: boolean) {\n    const lines = [];\n\n    lines.push(\n      '<?xml version=\"1.0\" encoding=\"UTF-8\" ?>',\n      '<settings xmlns=\"http://maven.apache.org/SETTINGS/1.0.0\"',\n      '        xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\"',\n      '        xsi:schemaLocation=\"http://maven.apache.org/SETTINGS/1.0.0',\n      '                            http://maven.apache.org/xsd/settings-1.0.0.xsd\">',\n      '  <servers>',\n      '    <server>',\n      `      <id>${serverId}</id>`,\n      // Maven will read these, surrounding code has already made sure they are set\n      '      <username>${env.MAVEN_USERNAME}</username>',\n      '      <password>${env.MAVEN_PASSWORD}</password>',\n      '    </server>',\n    );\n\n    if (signedArtifacts) {\n      lines.push(\n        '    <server>',\n        '      <id>gpg.passphrase</id>',\n        // Maven will read these, surrounding code has already made sure they are set\n        '      <passphrase>${env.MAVEN_GPG_PRIVATE_KEY_PASSPHRASE}</passphrase>',\n        '    </server>',\n      );\n    }\n\n    lines.push(\n      '  </servers>',\n      '</settings>',\n    );\n\n    await fs.writeFile(this.settingsFile, lines.join('\\n'), 'utf-8');\n  }\n\n  public async exec(mojo: string, options: MavenExecOptions): Promise<ProcessOutput | undefined> {\n    const args = [\n      `--settings=${this.settingsFile}`,\n      '--batch-mode',\n      ...(options.verbose ?? this.verbose ? ['-X'] : []),\n      mojo,\n      ...Object.entries(options.properties).map(([k, v]) => `-D${k}=${v}`),\n    ];\n\n    if (this.dryRun) {\n      echo(`[DRY-RUN] mvn ${args.map(quote).join(' ')}`);\n      return undefined;\n    }\n    const env = {\n      ...process.env,\n      JDK_JAVA_OPTIONS: [\n        // If we don't add this, we'll get an error like the following during the nexus-staging-maven-plugin:rc-release mojo.\n        // Don't know where this is coming from all of a sudden.\n        //\n        // [ERROR] message             : No converter available\n        // [ERROR] type                : java.util.Arrays$ArrayList\n        // [ERROR] converter           : com.thoughtworks.xstream.converters.reflection.ReflectionConverter\n        // [ERROR] message[1]          : Unable to make field protected transient int java.util.AbstractList.modCount accessible: module java.base does not \"opens java.util\" to unnamed module @7c8d5312\n        '--add-opens=java.base/java.util=ALL-UNNAMED',\n        '--add-opens=java.base/java.lang=ALL-UNNAMED',\n        '--add-opens=java.base/java.lang.invoke=ALL-UNNAMED',\n      ].join(' '),\n    };\n\n    return $({ verbose: true, nothrow: options.nothrow, env })`mvn ${args}`;\n  }\n}\n\ninterface MavenExecOptions {\n  properties: Record<string, string>;\n  nothrow?: boolean;\n  verbose?: boolean;\n}\n\n/**\n * A expected error that doesn't need a stack trace\n */\nclass SimpleError extends Error { }\n\n/**\n * Require an environment variable\n */\nfunction envVar(name: string): string {\n  const ret = process.env[name];\n  if (!ret) {\n    throw new SimpleError(`${name} is required`);\n  }\n  return ret;\n}\n\n/**\n * A temporary directory that cleans when it goes out of scope\n *\n * Use with `using`. Could have been async but it's depending\n * on an already-sync API, so why not sync?\n */\nexport function autoCleanDir() {\n  const dir = tmpdir();\n  return {\n    dir,\n    [Symbol.asyncDispose]: async () => {\n      await fs.rm(dir, { force: true, recursive: true });\n    },\n  };\n}\n\nfunction assertNever(value: never) {\n  throw new Error('Unexpected value: ' + value);\n}\n\n// A 'zx' primer\n//\n// - By default: stderr is printed to the terminal if it is captured.\n// - { verbose: true }: print the command, stdout and stderr to the terminal\n// - { quiet: true }: print neither stdout nor stderr\n//\n// .text(): return everything that's captured (stderr and stdout together if stderr is captured)\n\nmain().catch(e => {\n  if (e instanceof ProcessOutput) {\n    echo(`❌ Subprocess failed with exit code ${e.exitCode}`);\n  } else if (e instanceof SimpleError) {\n    echo('❌', e.message);\n  } else {\n    console.error(e);\n  }\n  process.exitCode = 1;\n});\n"]}