jsii-release 0.2.987 → 0.2.989

package/lib/bin/publib-maven.js

@@ -0,0 +1,608 @@
+"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,
+                stagingProfileId: envVar('MAVEN_STAGING_PROFILE_ID'),
+                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 {
+        const tty = (await (0, zx_1.$)({ stdio: ['inherit', 'pipe', 'pipe'] }) `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}`,
+            ...(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":"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","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        stagingProfileId: envVar('MAVEN_STAGING_PROFILE_ID'),\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    const tty = (await $({ stdio: ['inherit', 'pipe', 'pipe'] })`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      ...(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"]}