nx 19.8.0-canary.20240920-999abe9 → 19.8.1

package/src/command-line/release/changelog.js

@@ -242,7 +242,9 @@ function createAPI(overrideReleaseConfig) {
                     hasPushed = true;
                 }
                 output_1.output.logSingleLine(`Creating GitHub Release`);
-                await (0, github_1.createOrUpdateGithubRelease)(workspaceChangelog.releaseVersion, workspaceChangelog.contents, latestCommit, { dryRun: args.dryRun });
+                await (0, github_1.createOrUpdateGithubRelease)(nxReleaseConfig.changelog.workspaceChangelog
+                    ? nxReleaseConfig.changelog.workspaceChangelog.createRelease
+                    : config_1.defaultCreateReleaseProvider, workspaceChangelog.releaseVersion, workspaceChangelog.contents, latestCommit, { dryRun: args.dryRun });
             });
         }
         /**
@@ -401,7 +403,9 @@ function createAPI(overrideReleaseConfig) {
                                     hasPushed = true;
                                 }
                                 output_1.output.logSingleLine(`Creating GitHub Release`);
-                                await (0, github_1.createOrUpdateGithubRelease)(projectChangelog.releaseVersion, projectChangelog.contents, latestCommit, { dryRun: args.dryRun });
+                                await (0, github_1.createOrUpdateGithubRelease)(releaseGroup.changelog
+                                    ? releaseGroup.changelog.createRelease
+                                    : config_1.defaultCreateReleaseProvider, projectChangelog.releaseVersion, projectChangelog.contents, latestCommit, { dryRun: args.dryRun });
                             });
                         }
                         allProjectChangelogs[projectName] = projectChangelog;
@@ -516,7 +520,9 @@ function createAPI(overrideReleaseConfig) {
                                 hasPushed = true;
                             }
                             output_1.output.logSingleLine(`Creating GitHub Release`);
-                            await (0, github_1.createOrUpdateGithubRelease)(projectChangelog.releaseVersion, projectChangelog.contents, latestCommit, { dryRun: args.dryRun });
+                            await (0, github_1.createOrUpdateGithubRelease)(releaseGroup.changelog
+                                ? releaseGroup.changelog.createRelease
+                                : config_1.defaultCreateReleaseProvider, projectChangelog.releaseVersion, projectChangelog.contents, latestCommit, { dryRun: args.dryRun });
                         });
                     }
                     allProjectChangelogs[projectName] = projectChangelog;
@@ -730,14 +736,15 @@ async function generateChangelogForWorkspace({ tree, args, projectGraph, nxRelea
             title: `${prefix} an entry in ${interpolatedTreePath} for ${chalk.white(releaseVersion.gitTag)}`,
         });
     }
-    const githubRepoSlug = (0, github_1.getGitHubRepoSlug)(gitRemote);
+    const githubRepoData = (0, github_1.getGitHubRepoData)(gitRemote, config.createRelease);
     let contents = await changelogRenderer({
         projectGraph,
         changes,
         commits,
         releaseVersion: releaseVersion.rawVersion,
         project: null,
-        repoSlug: githubRepoSlug,
+        repoSlug: githubRepoData?.slug,
+        repoData: githubRepoData,
         entryWhenNoChanges: config.entryWhenNoChanges,
         changelogRenderOptions: config.renderOptions,
         conventionalCommitsConfig: nxReleaseConfig.conventionalCommits,
@@ -822,16 +829,15 @@ async function generateChangelogForProjects({ tree, args, projectGraph, changes,
                 title: `${prefix} an entry in ${interpolatedTreePath} for ${chalk.white(releaseVersion.gitTag)}`,
             });
         }
-        const githubRepoSlug = config.createRelease === 'github'
-            ? (0, github_1.getGitHubRepoSlug)(gitRemote)
-            : undefined;
+        const githubRepoData = (0, github_1.getGitHubRepoData)(gitRemote, config.createRelease);
         let contents = await changelogRenderer({
             projectGraph,
             changes,
             commits,
             releaseVersion: releaseVersion.rawVersion,
             project: project.name,
-            repoSlug: githubRepoSlug,
+            repoSlug: githubRepoData?.slug,
+            repoData: githubRepoData,
             entryWhenNoChanges: typeof config.entryWhenNoChanges === 'string'
                 ? (0, utils_1.interpolate)(config.entryWhenNoChanges, {
                     projectName: project.name,
@@ -937,7 +943,7 @@ function shouldCreateGitHubRelease(changelogConfig, createReleaseArg = undefined
     if (createReleaseArg !== undefined) {
         return createReleaseArg === 'github';
     }
-    return (changelogConfig || {}).createRelease === 'github';
+    return (changelogConfig || {}).createRelease !== false;
 }
 async function promptForGitHubRelease() {
     try {

package/src/command-line/release/config/config.d.ts

@@ -42,7 +42,7 @@ export type NxReleaseConfig = Omit<DeepRequired<NxJsonConfiguration['release'] &
     };
 }>, 'projects'>;
 export interface CreateNxReleaseConfigError {
-    code: 'PROJECTS_AND_GROUPS_DEFINED' | 'RELEASE_GROUP_MATCHES_NO_PROJECTS' | 'RELEASE_GROUP_RELEASE_TAG_PATTERN_VERSION_PLACEHOLDER_MISSING_OR_EXCESSIVE' | 'PROJECT_MATCHES_MULTIPLE_GROUPS' | 'CONVENTIONAL_COMMITS_SHORTHAND_MIXED_WITH_OVERLAPPING_GENERATOR_OPTIONS' | 'GLOBAL_GIT_CONFIG_MIXED_WITH_GRANULAR_GIT_CONFIG';
+    code: 'PROJECTS_AND_GROUPS_DEFINED' | 'RELEASE_GROUP_MATCHES_NO_PROJECTS' | 'RELEASE_GROUP_RELEASE_TAG_PATTERN_VERSION_PLACEHOLDER_MISSING_OR_EXCESSIVE' | 'PROJECT_MATCHES_MULTIPLE_GROUPS' | 'CONVENTIONAL_COMMITS_SHORTHAND_MIXED_WITH_OVERLAPPING_GENERATOR_OPTIONS' | 'GLOBAL_GIT_CONFIG_MIXED_WITH_GRANULAR_GIT_CONFIG' | 'CANNOT_RESOLVE_CHANGELOG_RENDERER' | 'INVALID_CHANGELOG_CREATE_RELEASE_PROVIDER' | 'INVALID_CHANGELOG_CREATE_RELEASE_HOSTNAME' | 'INVALID_CHANGELOG_CREATE_RELEASE_API_BASE_URL';
     data: Record<string, string | string[]>;
 }
 export declare function createNxReleaseConfig(projectGraph: ProjectGraph, projectFileMap: ProjectFileMap, userConfig?: NxJsonConfiguration['release']): Promise<{
@@ -50,4 +50,5 @@ export declare function createNxReleaseConfig(projectGraph: ProjectGraph, projec
     nxReleaseConfig: NxReleaseConfig | null;
 }>;
 export declare function handleNxReleaseConfigError(error: CreateNxReleaseConfigError): Promise<never>;
+export declare const defaultCreateReleaseProvider: any;
 export {};

package/src/command-line/release/config/config.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.IMPLICIT_DEFAULT_RELEASE_GROUP = void 0;
+exports.defaultCreateReleaseProvider = exports.IMPLICIT_DEFAULT_RELEASE_GROUP = void 0;
 exports.createNxReleaseConfig = createNxReleaseConfig;
 exports.handleNxReleaseConfigError = handleNxReleaseConfigError;
 /**
@@ -17,6 +17,7 @@ exports.handleNxReleaseConfigError = handleNxReleaseConfigError;
  * and easy to consume config object for all the `nx release` command implementations.
  */
 const node_path_1 = require("node:path");
+const node_url_1 = require("node:url");
 const fileutils_1 = require("../../../utils/fileutils");
 const find_matching_projects_1 = require("../../../utils/find-matching-projects");
 const output_1 = require("../../../utils/output");
@@ -368,7 +369,13 @@ async function createNxReleaseConfig(projectGraph, projectFileMap, userConfig =
         }
         releaseGroups[releaseGroupName] = finalReleaseGroup;
     }
-    ensureChangelogRenderersAreResolvable(releaseGroups, rootChangelogConfig);
+    const configError = validateChangelogConfig(releaseGroups, rootChangelogConfig);
+    if (configError) {
+        return {
+            error: configError,
+            nxReleaseConfig: null,
+        };
+    }
     return {
         error: null,
         nxReleaseConfig: {
@@ -547,6 +554,48 @@ async function handleNxReleaseConfigError(error) {
                 });
             }
             break;
+        case 'CANNOT_RESOLVE_CHANGELOG_RENDERER': {
+            const nxJsonMessage = await (0, resolve_nx_json_error_message_1.resolveNxJsonConfigErrorMessage)(['release']);
+            output_1.output.error({
+                title: `There was an error when resolving the configured changelog renderer at path: ${error.data.workspaceRelativePath}`,
+                bodyLines: [nxJsonMessage],
+            });
+        }
+        case 'INVALID_CHANGELOG_CREATE_RELEASE_PROVIDER':
+            {
+                const nxJsonMessage = await (0, resolve_nx_json_error_message_1.resolveNxJsonConfigErrorMessage)([
+                    'release',
+                ]);
+                output_1.output.error({
+                    title: `Your "changelog.createRelease" config specifies an unsupported provider "${error.data.provider}". The supported providers are ${error.data.supportedProviders
+                        .map((p) => `"${p}"`)
+                        .join(', ')}`,
+                    bodyLines: [nxJsonMessage],
+                });
+            }
+            break;
+        case 'INVALID_CHANGELOG_CREATE_RELEASE_HOSTNAME':
+            {
+                const nxJsonMessage = await (0, resolve_nx_json_error_message_1.resolveNxJsonConfigErrorMessage)([
+                    'release',
+                ]);
+                output_1.output.error({
+                    title: `Your "changelog.createRelease" config specifies an invalid hostname "${error.data.hostname}". Please ensure you provide a valid hostname value, such as "example.com"`,
+                    bodyLines: [nxJsonMessage],
+                });
+            }
+            break;
+        case 'INVALID_CHANGELOG_CREATE_RELEASE_API_BASE_URL':
+            {
+                const nxJsonMessage = await (0, resolve_nx_json_error_message_1.resolveNxJsonConfigErrorMessage)([
+                    'release',
+                ]);
+                output_1.output.error({
+                    title: `Your "changelog.createRelease" config specifies an invalid apiBaseUrl "${error.data.apiBaseUrl}". Please ensure you provide a valid URL value, such as "https://example.com"`,
+                    bodyLines: [nxJsonMessage],
+                });
+            }
+            break;
         default:
             throw new Error(`Unhandled error code: ${error.code}`);
     }
@@ -678,42 +727,138 @@ function isProjectPublic(project, projectGraph, projectFileMap) {
         return false;
     }
 }
-function ensureChangelogRenderersAreResolvable(releaseGroups, rootChangelogConfig) {
+/**
+ * We need to ensure that changelog renderers are resolvable up front so that we do not end up erroring after performing
+ * actions later, and we also make sure that any configured createRelease options are valid.
+ *
+ * For the createRelease config, we also set a default apiBaseUrl if applicable.
+ */
+function validateChangelogConfig(releaseGroups, rootChangelogConfig) {
     /**
      * If any form of changelog config is enabled, ensure that any provided changelog renderers are resolvable
      * up front so that we do not end up erroring only after the versioning step has been completed.
      */
     const uniqueRendererPaths = new Set();
     if (rootChangelogConfig.workspaceChangelog &&
-        typeof rootChangelogConfig.workspaceChangelog !== 'boolean' &&
-        rootChangelogConfig.workspaceChangelog.renderer?.length) {
-        uniqueRendererPaths.add(rootChangelogConfig.workspaceChangelog.renderer);
+        typeof rootChangelogConfig.workspaceChangelog !== 'boolean') {
+        if (rootChangelogConfig.workspaceChangelog.renderer?.length) {
+            uniqueRendererPaths.add(rootChangelogConfig.workspaceChangelog.renderer);
+        }
+        const createReleaseError = validateCreateReleaseConfig(rootChangelogConfig.workspaceChangelog);
+        if (createReleaseError) {
+            return createReleaseError;
+        }
     }
     if (rootChangelogConfig.projectChangelogs &&
-        typeof rootChangelogConfig.projectChangelogs !== 'boolean' &&
-        rootChangelogConfig.projectChangelogs.renderer?.length) {
-        uniqueRendererPaths.add(rootChangelogConfig.projectChangelogs.renderer);
+        typeof rootChangelogConfig.projectChangelogs !== 'boolean') {
+        if (rootChangelogConfig.projectChangelogs.renderer?.length) {
+            uniqueRendererPaths.add(rootChangelogConfig.projectChangelogs.renderer);
+        }
+        const createReleaseError = validateCreateReleaseConfig(rootChangelogConfig.projectChangelogs);
+        if (createReleaseError) {
+            return createReleaseError;
+        }
     }
     for (const group of Object.values(releaseGroups)) {
-        if (group.changelog &&
-            typeof group.changelog !== 'boolean' &&
-            group.changelog.renderer?.length) {
-            uniqueRendererPaths.add(group.changelog.renderer);
+        if (group.changelog && typeof group.changelog !== 'boolean') {
+            if (group.changelog.renderer?.length) {
+                uniqueRendererPaths.add(group.changelog.renderer);
+            }
+            const createReleaseError = validateCreateReleaseConfig(group.changelog);
+            if (createReleaseError) {
+                return createReleaseError;
+            }
         }
     }
     if (!uniqueRendererPaths.size) {
-        return;
+        return null;
     }
     for (const rendererPath of uniqueRendererPaths) {
         try {
             (0, resolve_changelog_renderer_1.resolveChangelogRenderer)(rendererPath);
         }
-        catch (e) {
-            const workspaceRelativePath = (0, node_path_1.relative)(workspace_root_1.workspaceRoot, rendererPath);
-            output_1.output.error({
-                title: `There was an error when resolving the configured changelog renderer at path: ${workspaceRelativePath}`,
-            });
-            throw e;
+        catch {
+            return {
+                code: 'CANNOT_RESOLVE_CHANGELOG_RENDERER',
+                data: {
+                    workspaceRelativePath: (0, node_path_1.relative)(workspace_root_1.workspaceRoot, rendererPath),
+                },
+            };
         }
     }
+    return null;
+}
+const supportedCreateReleaseProviders = [
+    {
+        name: 'github-enterprise-server',
+        defaultApiBaseUrl: 'https://__hostname__/api/v3',
+    },
+];
+// User opts into the default by specifying the string value 'github'
+exports.defaultCreateReleaseProvider = {
+    provider: 'github',
+    hostname: 'github.com',
+    apiBaseUrl: 'https://api.github.com',
+};
+function validateCreateReleaseConfig(changelogConfig) {
+    const createRelease = changelogConfig.createRelease;
+    // Disabled: valid
+    if (!createRelease) {
+        return null;
+    }
+    // GitHub shorthand, expand to full object form, mark as valid
+    if (createRelease === 'github') {
+        changelogConfig.createRelease = exports.defaultCreateReleaseProvider;
+        return null;
+    }
+    // Object config, ensure that properties are valid
+    const supportedProvider = supportedCreateReleaseProviders.find((p) => p.name === createRelease.provider);
+    if (!supportedProvider) {
+        return {
+            code: 'INVALID_CHANGELOG_CREATE_RELEASE_PROVIDER',
+            data: {
+                provider: createRelease.provider,
+                supportedProviders: supportedCreateReleaseProviders.map((p) => p.name),
+            },
+        };
+    }
+    if (!isValidHostname(createRelease.hostname)) {
+        return {
+            code: 'INVALID_CHANGELOG_CREATE_RELEASE_HOSTNAME',
+            data: {
+                hostname: createRelease.hostname,
+            },
+        };
+    }
+    // user provided a custom apiBaseUrl, ensure it is valid (accounting for empty string case)
+    if (createRelease.apiBaseUrl ||
+        typeof createRelease.apiBaseUrl === 'string') {
+        if (!isValidUrl(createRelease.apiBaseUrl)) {
+            return {
+                code: 'INVALID_CHANGELOG_CREATE_RELEASE_API_BASE_URL',
+                data: {
+                    apiBaseUrl: createRelease.apiBaseUrl,
+                },
+            };
+        }
+    }
+    else {
+        // Set default apiBaseUrl when not provided by the user
+        createRelease.apiBaseUrl = supportedProvider.defaultApiBaseUrl.replace('__hostname__', createRelease.hostname);
+    }
+    return null;
+}
+function isValidHostname(hostname) {
+    // Regular expression to match a valid hostname
+    const hostnameRegex = /^(?!:\/\/)(?=.{1,255}$)(?!.*\.$)(?!.*?\.\.)(?!.*?-$)(?!^-)([a-zA-Z0-9-]{1,63}\.?)+[a-zA-Z]{2,}$/;
+    return hostnameRegex.test(hostname);
+}
+function isValidUrl(str) {
+    try {
+        new node_url_1.URL(str);
+        return true;
+    }
+    catch {
+        return false;
+    }
 }

package/src/command-line/release/config/version-plans.js

@@ -191,7 +191,9 @@ function isReleaseType(value) {
 }
 async function getCommitForVersionPlanFile(rawVersionPlan, isVerbose) {
     return new Promise((resolve) => {
-        (0, node_child_process_1.exec)(`git log --diff-filter=A --pretty=format:"%s|%h|%an|%ae|%b" -n 1 -- ${rawVersionPlan.absolutePath}`, (error, stdout, stderr) => {
+        (0, node_child_process_1.exec)(`git log --diff-filter=A --pretty=format:"%s|%h|%an|%ae|%b" -n 1 -- ${rawVersionPlan.absolutePath}`, {
+            windowsHide: true,
+        }, (error, stdout, stderr) => {
             if (error) {
                 if (isVerbose) {
                     console.error(`Error executing git command for ${rawVersionPlan.relativePath}: ${error.message}`);

package/src/command-line/release/release.js

@@ -168,7 +168,9 @@ function createAPI(overrideReleaseConfig) {
             hasPushedChanges = true;
             output_1.output.logSingleLine(`Creating GitHub Release`);
             latestCommit = await (0, git_1.getCommitHash)('HEAD');
-            await (0, github_1.createOrUpdateGithubRelease)(changelogResult.workspaceChangelog.releaseVersion, changelogResult.workspaceChangelog.contents, latestCommit, { dryRun: args.dryRun });
+            await (0, github_1.createOrUpdateGithubRelease)(nxReleaseConfig.changelog.workspaceChangelog
+                ? nxReleaseConfig.changelog.workspaceChangelog.createRelease
+                : false, changelogResult.workspaceChangelog.releaseVersion, changelogResult.workspaceChangelog.contents, latestCommit, { dryRun: args.dryRun });
         }
         for (const releaseGroup of releaseGroups) {
             const shouldCreateProjectReleases = (0, changelog_1.shouldCreateGitHubRelease)(releaseGroup.changelog);
@@ -197,7 +199,9 @@ function createAPI(overrideReleaseConfig) {
                     if (!latestCommit) {
                         latestCommit = await (0, git_1.getCommitHash)('HEAD');
                     }
-                    await (0, github_1.createOrUpdateGithubRelease)(changelog.releaseVersion, changelog.contents, latestCommit, { dryRun: args.dryRun });
+                    await (0, github_1.createOrUpdateGithubRelease)(releaseGroup.changelog
+                        ? releaseGroup.changelog.createRelease
+                        : false, changelog.releaseVersion, changelog.contents, latestCommit, { dryRun: args.dryRun });
                 }
             }
         }

package/src/command-line/release/utils/exec-command.js

@@ -8,6 +8,7 @@ async function execCommand(cmd, args, options) {
             ...options,
             stdio: ['pipe', 'pipe', 'pipe'], // stdin, stdout, stderr
             encoding: 'utf-8',
+            windowsHide: true,
         });
         let stdout = '';
         let stderr = '';

package/src/command-line/release/utils/github.d.ts

@@ -1,11 +1,14 @@
+import { NxReleaseChangelogConfiguration } from '../../../config/nx-json';
 import { Reference } from './git';
 import { ReleaseVersion } from './shared';
 export type RepoSlug = `${string}/${string}`;
-export interface GithubRequestConfig {
+interface GithubRequestConfig {
     repo: string;
+    hostname: string;
+    apiBaseUrl: string;
     token: string | null;
 }
-export interface GithubRelease {
+interface GithubRelease {
     id?: string;
     tag_name: string;
     target_commitish?: string;
@@ -14,10 +17,15 @@ export interface GithubRelease {
     draft?: boolean;
     prerelease?: boolean;
 }
-export declare function getGitHubRepoSlug(remoteName?: string): RepoSlug;
-export declare function createOrUpdateGithubRelease(releaseVersion: ReleaseVersion, changelogContents: string, latestCommit: string, { dryRun }: {
+export interface GithubRepoData {
+    hostname: string;
+    slug: RepoSlug;
+    apiBaseUrl: string;
+}
+export declare function getGitHubRepoData(remoteName: string, createReleaseConfig: NxReleaseChangelogConfiguration['createRelease']): GithubRepoData | null;
+export declare function createOrUpdateGithubRelease(createReleaseConfig: NxReleaseChangelogConfiguration['createRelease'], releaseVersion: ReleaseVersion, changelogContents: string, latestCommit: string, { dryRun }: {
     dryRun: boolean;
 }): Promise<void>;
-export declare function resolveGithubToken(): Promise<string | null>;
 export declare function getGithubReleaseByTag(config: GithubRequestConfig, tag: string): Promise<GithubRelease>;
-export declare function formatReferences(references: Reference[], repoSlug: RepoSlug): string;
+export declare function formatReferences(references: Reference[], repoData: GithubRepoData): string;
+export {};

package/src/command-line/release/utils/github.js

@@ -1,8 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getGitHubRepoSlug = getGitHubRepoSlug;
+exports.getGitHubRepoData = getGitHubRepoData;
 exports.createOrUpdateGithubRelease = createOrUpdateGithubRelease;
-exports.resolveGithubToken = resolveGithubToken;
 exports.getGithubReleaseByTag = getGithubReleaseByTag;
 exports.formatReferences = formatReferences;
 const chalk = require("chalk");
@@ -12,22 +11,38 @@ const node_fs_1 = require("node:fs");
 const node_os_1 = require("node:os");
 const output_1 = require("../../../utils/output");
 const path_1 = require("../../../utils/path");
+const config_1 = require("../config/config");
 const print_changes_1 = require("./print-changes");
 const shared_1 = require("./shared");
 // axios types and values don't seem to match
 const _axios = require("axios");
 const axios = _axios;
-function getGitHubRepoSlug(remoteName = 'origin') {
+function getGitHubRepoData(remoteName = 'origin', createReleaseConfig) {
     try {
         const remoteUrl = (0, node_child_process_1.execSync)(`git remote get-url ${remoteName}`, {
             encoding: 'utf8',
             stdio: 'pipe',
         }).trim();
+        // Use the default provider (github.com) if custom one is not specified or releases are disabled
+        let hostname = config_1.defaultCreateReleaseProvider.hostname;
+        let apiBaseUrl = config_1.defaultCreateReleaseProvider.apiBaseUrl;
+        if (createReleaseConfig !== false &&
+            typeof createReleaseConfig !== 'string') {
+            hostname = createReleaseConfig.hostname;
+            apiBaseUrl = createReleaseConfig.apiBaseUrl;
+        }
         // Extract the 'user/repo' part from the URL
-        const regex = /github\.com[/:]([\w-]+\/[\w-]+)/;
+        const escapedHostname = hostname.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+        const regexString = `${escapedHostname}[/:]([\\w.-]+/[\\w.-]+)(\\.git)?`;
+        const regex = new RegExp(regexString);
         const match = remoteUrl.match(regex);
         if (match && match[1]) {
-            return match[1];
+            return {
+                hostname,
+                apiBaseUrl,
+                // Ensure any trailing .git is stripped
+                slug: match[1].replace(/\.git$/, ''),
+            };
         }
         else {
             throw new Error(`Could not extract "user/repo" data from the resolved remote URL: ${remoteUrl}`);
@@ -37,9 +52,9 @@ function getGitHubRepoSlug(remoteName = 'origin') {
         return null;
     }
 }
-async function createOrUpdateGithubRelease(releaseVersion, changelogContents, latestCommit, { dryRun }) {
-    const githubRepoSlug = getGitHubRepoSlug();
-    if (!githubRepoSlug) {
+async function createOrUpdateGithubRelease(createReleaseConfig, releaseVersion, changelogContents, latestCommit, { dryRun }) {
+    const githubRepoData = getGitHubRepoData(undefined, createReleaseConfig);
+    if (!githubRepoData) {
         output_1.output.error({
             title: `Unable to create a GitHub release because the GitHub repo slug could not be determined.`,
             bodyLines: [
@@ -48,9 +63,11 @@ async function createOrUpdateGithubRelease(releaseVersion, changelogContents, la
         });
         process.exit(1);
     }
-    const token = await resolveGithubToken();
+    const token = await resolveGithubToken(githubRepoData.hostname);
     const githubRequestConfig = {
-        repo: githubRepoSlug,
+        repo: githubRepoData.slug,
+        hostname: githubRepoData.hostname,
+        apiBaseUrl: githubRepoData.apiBaseUrl,
         token,
     };
     let existingGithubReleaseForVersion;
@@ -76,7 +93,7 @@ async function createOrUpdateGithubRelease(releaseVersion, changelogContents, la
             throw err;
         }
     }
-    const logTitle = `https://github.com/${githubRepoSlug}/releases/tag/${releaseVersion.gitTag}`;
+    const logTitle = `https://${githubRepoData.hostname}/${githubRepoData.slug}/releases/tag/${releaseVersion.gitTag}`;
     if (existingGithubReleaseForVersion) {
         console.error(`${chalk.white('UPDATE')} ${logTitle}${dryRun ? chalk.keyword('orange')(' [dry-run]') : ''}`);
     }
@@ -215,7 +232,7 @@ async function syncGithubRelease(githubRequestConfig, release, existingGithubRel
         };
     }
 }
-async function resolveGithubToken() {
+async function resolveGithubToken(hostname) {
     // Try and resolve from the environment
     const tokenFromEnv = process.env.GITHUB_TOKEN || process.env.GH_TOKEN;
     if (tokenFromEnv) {
@@ -227,21 +244,25 @@ async function resolveGithubToken() {
         const yamlContents = await node_fs_1.promises.readFile(ghCLIPath, 'utf8');
         const { load } = require('@zkochan/js-yaml');
         const ghCLIConfig = load(yamlContents);
-        if (ghCLIConfig['github.com']) {
+        if (ghCLIConfig[hostname]) {
             // Web based session (the token is already embedded in the config)
-            if (ghCLIConfig['github.com'].oauth_token) {
-                return ghCLIConfig['github.com'].oauth_token;
+            if (ghCLIConfig[hostname].oauth_token) {
+                return ghCLIConfig[hostname].oauth_token;
             }
             // SSH based session (we need to dynamically resolve a token using the CLI)
-            if (ghCLIConfig['github.com'].user &&
-                ghCLIConfig['github.com'].git_protocol === 'ssh') {
+            if (ghCLIConfig[hostname].user &&
+                ghCLIConfig[hostname].git_protocol === 'ssh') {
                 return (0, node_child_process_1.execSync)(`gh auth token`, {
                     encoding: 'utf8',
                     stdio: 'pipe',
+                    windowsHide: true,
                 }).trim();
             }
         }
     }
+    if (hostname !== 'github.com') {
+        console.log(`Warning: It was not possible to automatically resolve a GitHub token from your environment for hostname ${hostname}. If you set the GITHUB_TOKEN or GH_TOKEN environment variable, that will be used for GitHub API requests.`);
+    }
     return null;
 }
 async function getGithubReleaseByTag(config, tag) {
@@ -250,7 +271,7 @@ async function getGithubReleaseByTag(config, tag) {
 async function makeGithubRequest(config, url, opts = {}) {
     return (await axios(url, {
         ...opts,
-        baseURL: 'https://api.github.com',
+        baseURL: config.apiBaseUrl,
         headers: {
             ...opts.headers,
             Authorization: config.token ? `Bearer ${config.token}` : undefined,
@@ -270,27 +291,32 @@ async function updateGithubRelease(config, id, body) {
     });
 }
 function githubNewReleaseURL(config, release) {
-    return `https://github.com/${config.repo}/releases/new?tag=${release.version}&title=${release.version}&body=${encodeURIComponent(release.body)}`;
+    // Parameters taken from https://github.com/isaacs/github/issues/1410#issuecomment-442240267
+    let url = `https://${config.hostname}/${config.repo}/releases/new?tag=${release.version}&title=${release.version}&body=${encodeURIComponent(release.body)}&target=${release.commit}`;
+    if (release.prerelease) {
+        url += '&prerelease=true';
+    }
+    return url;
 }
 const providerToRefSpec = {
     github: { 'pull-request': 'pull', hash: 'commit', issue: 'issues' },
 };
-function formatReference(ref, repoSlug) {
+function formatReference(ref, repoData) {
     const refSpec = providerToRefSpec['github'];
-    return `[${ref.value}](https://github.com/${repoSlug}/${refSpec[ref.type]}/${ref.value.replace(/^#/, '')})`;
+    return `[${ref.value}](https://${repoData.hostname}/${repoData.slug}/${refSpec[ref.type]}/${ref.value.replace(/^#/, '')})`;
 }
-function formatReferences(references, repoSlug) {
+function formatReferences(references, repoData) {
     const pr = references.filter((ref) => ref.type === 'pull-request');
     const issue = references.filter((ref) => ref.type === 'issue');
     if (pr.length > 0 || issue.length > 0) {
         return (' (' +
             [...pr, ...issue]
-                .map((ref) => formatReference(ref, repoSlug))
+                .map((ref) => formatReference(ref, repoData))
                 .join(', ') +
             ')');
     }
     if (references.length > 0) {
-        return ' (' + formatReference(references[0], repoSlug) + ')';
+        return ' (' + formatReference(references[0], repoData) + ')';
     }
     return '';
 }

package/src/command-line/release/utils/launch-editor.js

@@ -13,6 +13,7 @@ async function launchEditor(filePath) {
     return new Promise((resolve, reject) => {
         const editorProcess = (0, node_child_process_1.spawn)(cmd, [...args, filePath], {
             stdio: 'inherit', // This will ensure the editor uses the current terminal
+            windowsHide: true,
         });
         editorProcess.on('exit', (code) => {
             if (code === 0) {
@@ -26,7 +27,11 @@ async function launchEditor(filePath) {
 }
 function getGitConfig(key) {
     try {
-        return (0, node_child_process_1.execSync)(`git config --get ${key}`).toString().trim();
+        return (0, node_child_process_1.execSync)(`git config --get ${key}`, {
+            windowsHide: true,
+        })
+            .toString()
+            .trim();
     }
     catch {
         return null;

package/src/command-line/release/version.js

@@ -210,7 +210,7 @@ function createAPI(overrideReleaseConfig) {
             runPreVersionCommand(releaseGroup.version.groupPreVersionCommand, {
                 dryRun: args.dryRun,
                 verbose: args.verbose,
-            });
+            }, releaseGroup);
             const projectBatches = (0, batch_projects_by_generator_config_1.batchProjectsByGeneratorConfig)(projectGraph, releaseGroup, 
             // Batch based on all projects within the release group
             releaseGroup.projects);
@@ -412,11 +412,13 @@ function resolveGeneratorData({ collectionName, generatorName, configGeneratorOp
         throw err;
     }
 }
-function runPreVersionCommand(preVersionCommand, { dryRun, verbose }) {
+function runPreVersionCommand(preVersionCommand, { dryRun, verbose }, releaseGroup) {
     if (!preVersionCommand) {
         return;
     }
-    output_1.output.logSingleLine(`Executing pre-version command`);
+    output_1.output.logSingleLine(releaseGroup
+        ? `Executing release group pre-version command for "${releaseGroup.name}"`
+        : `Executing pre-version command`);
     if (verbose) {
         console.log(`Executing the following pre-version command:`);
         console.log(preVersionCommand);
@@ -434,6 +436,7 @@ function runPreVersionCommand(preVersionCommand, { dryRun, verbose }) {
             maxBuffer: LARGE_BUFFER,
             stdio,
             env,
+            windowsHide: true,
         });
     }
     catch (e) {

package/src/command-line/report/report.d.ts

@@ -1,6 +1,7 @@
 import { PackageManager } from '../../utils/package-manager';
 import { PackageJson } from '../../utils/package-json';
 import { NxJsonConfiguration } from '../../config/nx-json';
+import type { PowerpackLicense } from '@nx/powerpack-license';
 export declare const packagesWeCareAbout: string[];
 export declare const patternsWeIgnoreInCommunityReport: Array<string | RegExp>;
 /**
@@ -15,7 +16,8 @@ export declare function reportHandler(): Promise<void>;
 export interface ReportData {
     pm: PackageManager;
     pmVersion: string;
-    powerpackLicense: any | null;
+    powerpackLicense: PowerpackLicense | null;
+    powerpackError: Error | null;
     powerpackPlugins: PackageJson[];
     localPlugins: string[];
     communityPlugins: PackageJson[];