keycloakify 10.0.0-rc.4 → 10.0.0-rc.6

package/src/bin/keycloakify/{generateTheme/generateThemeVariants.ts → generateSrcMainResources/generateSrcMainResourcesForThemeVariant.ts}

@@ -1,12 +1,19 @@
 import { join as pathJoin, extname as pathExtname, sep as pathSep } from "path";
 import { transformCodebase } from "../../tools/transformCodebase";
+import type { BuildOptions } from "../../shared/buildOptions";
+import { readMetaInfKeycloakThemes, writeMetaInfKeycloakThemes } from "../../shared/metaInfKeycloakThemes";
 import { assert } from "tsafe/assert";
-import * as fs from "fs";
 
-export function generateThemeVariations(params: { themeName: string; themeVariantName: string; srcMainResourcesDirPath: string }) {
-    const { themeName, themeVariantName, srcMainResourcesDirPath } = params;
+export type BuildOptionsLike = {
+    keycloakifyBuildDirPath: string;
+};
 
-    const mainThemeDirPath = pathJoin(srcMainResourcesDirPath, "theme", themeName);
+assert<BuildOptions extends BuildOptionsLike ? true : false>();
+
+export function generateSrcMainResourcesForThemeVariant(params: { themeName: string; themeVariantName: string; buildOptions: BuildOptionsLike }) {
+    const { themeName, themeVariantName, buildOptions } = params;
+
+    const mainThemeDirPath = pathJoin(buildOptions.keycloakifyBuildDirPath, "src", "main", "resources", "theme", themeName);
 
     transformCodebase({
         "srcDirPath": mainThemeDirPath,
@@ -30,21 +37,20 @@ export function generateThemeVariations(params: { themeName: string; themeVarian
     });
 
     {
-        const keycloakThemeJsonFilePath = pathJoin(srcMainResourcesDirPath, "META-INF", "keycloak-themes.json");
+        const updatedMetaInfKeycloakThemes = readMetaInfKeycloakThemes({ "keycloakifyBuildDirPath": buildOptions.keycloakifyBuildDirPath });
 
-        const modifiedParsedJson = JSON.parse(fs.readFileSync(keycloakThemeJsonFilePath).toString("utf8")) as {
-            themes: { name: string; types: string[] }[];
-        };
-
-        modifiedParsedJson.themes.push({
+        updatedMetaInfKeycloakThemes.themes.push({
             "name": themeVariantName,
             "types": (() => {
-                const theme = modifiedParsedJson.themes.find(({ name }) => name === themeName);
+                const theme = updatedMetaInfKeycloakThemes.themes.find(({ name }) => name === themeName);
                 assert(theme !== undefined);
                 return theme.types;
             })()
         });
 
-        fs.writeFileSync(keycloakThemeJsonFilePath, Buffer.from(JSON.stringify(modifiedParsedJson, null, 2), "utf8"));
+        writeMetaInfKeycloakThemes({
+            "keycloakifyBuildDirPath": buildOptions.keycloakifyBuildDirPath,
+            "metaInfKeycloakThemes": updatedMetaInfKeycloakThemes
+        });
     }
 }

package/src/bin/keycloakify/generateSrcMainResources/index.ts

@@ -0,0 +1 @@
+export * from "./generateSrcMainResources";

package/src/bin/keycloakify/{generateTheme → generateSrcMainResources}/readExtraPageNames.ts

@@ -1,10 +1,10 @@
 import { crawl } from "../../tools/crawl";
-import { accountThemePageIds, loginThemePageIds } from "../generateFtl";
+import { accountThemePageIds, loginThemePageIds } from "../../shared/pageIds";
 import { id } from "tsafe/id";
 import { removeDuplicates } from "evt/tools/reducers/removeDuplicates";
 import * as fs from "fs";
 import { join as pathJoin } from "path";
-import type { ThemeType } from "../../constants";
+import type { ThemeType } from "../../shared/constants";
 
 export function readExtraPagesNames(params: { themeSrcDirPath: string; themeType: ThemeType }): string[] {
     const { themeSrcDirPath, themeType } = params;

package/src/bin/keycloakify/{generateTheme → generateSrcMainResources}/readFieldNameUsage.ts

@@ -1,15 +1,16 @@
 import { crawl } from "../../tools/crawl";
 import { join as pathJoin } from "path";
 import * as fs from "fs";
-import type { ThemeType } from "../../constants";
+import type { ThemeType } from "../../shared/constants";
+import { getThisCodebaseRootDirPath } from "../../tools/getThisCodebaseRootDirPath";
 
 /** Assumes the theme type exists */
-export function readFieldNameUsage(params: { keycloakifySrcDirPath: string; themeSrcDirPath: string; themeType: ThemeType }): string[] {
-    const { keycloakifySrcDirPath, themeSrcDirPath, themeType } = params;
+export function readFieldNameUsage(params: { themeSrcDirPath: string; themeType: ThemeType }): string[] {
+    const { themeSrcDirPath, themeType } = params;
 
     const fieldNames = new Set<string>();
 
-    for (const srcDirPath of [pathJoin(keycloakifySrcDirPath, themeType), pathJoin(themeSrcDirPath, themeType)]) {
+    for (const srcDirPath of [pathJoin(getThisCodebaseRootDirPath(), "src", themeType), pathJoin(themeSrcDirPath, themeType)]) {
         const filePaths = crawl({ "dirPath": srcDirPath, "returnedPathsType": "absolute" }).filter(filePath => /\.(ts|tsx|js|jsx)$/.test(filePath));
 
         for (const filePath of filePaths) {

package/src/bin/keycloakify/generateStartKeycloakTestingContainer.ts

@@ -1,8 +1,8 @@
 import * as fs from "fs";
 import { join as pathJoin, relative as pathRelative, basename as pathBasename } from "path";
 import { assert } from "tsafe/assert";
-import type { BuildOptions } from "./buildOptions";
-import { accountV1ThemeName } from "../constants";
+import type { BuildOptions } from "../shared/buildOptions";
+import { accountV1ThemeName } from "../shared/constants";
 
 export type BuildOptionsLike = {
     keycloakifyBuildDirPath: string;

package/src/bin/keycloakify/index.ts

@@ -1,8 +1 @@
-#!/usr/bin/env node
-
 export * from "./keycloakify";
-import { main } from "./keycloakify";
-
-if (require.main === module) {
-    main();
-}

package/src/bin/keycloakify/keycloakify.ts

@@ -1,25 +1,21 @@
-import { generateTheme } from "./generateTheme";
+import { generateSrcMainResources } from "./generateSrcMainResources";
 import { join as pathJoin, relative as pathRelative, sep as pathSep } from "path";
 import * as child_process from "child_process";
-import { generateStartKeycloakTestingContainer } from "./generateStartKeycloakTestingContainer";
 import * as fs from "fs";
-import { readBuildOptions } from "./buildOptions";
+import { readBuildOptions } from "../shared/buildOptions";
 import { getLogger } from "../tools/logger";
-import { getThemeSrcDirPath } from "../getThemeSrcDirPath";
-import { getThisCodebaseRootDirPath } from "../tools/getThisCodebaseRootDirPath";
-import { readThisNpmProjectVersion } from "../tools/readThisNpmProjectVersion";
-import { keycloakifyBuildOptionsForPostPostBuildScriptEnvName } from "../constants";
+import { vitePluginSubScriptEnvNames } from "../shared/constants";
 import { buildJars } from "./buildJars";
+import type { CliCommandOptions } from "../main";
 
-export async function main() {
-    const buildOptions = readBuildOptions({
-        "processArgv": process.argv.slice(2)
-    });
+export async function command(params: { cliCommandOptions: CliCommandOptions }) {
+    const { cliCommandOptions } = params;
+
+    const buildOptions = readBuildOptions({ cliCommandOptions });
 
     const logger = getLogger({ "isSilent": buildOptions.isSilent });
-    logger.log("🔏 Building the keycloak theme...⌚");
 
-    const { themeSrcDirPath } = getThemeSrcDirPath({ "reactAppRootDirPath": buildOptions.reactAppRootDirPath });
+    logger.log("🔏 Building the keycloak theme...⌚");
 
     {
         if (!fs.existsSync(buildOptions.keycloakifyBuildDirPath)) {
@@ -29,12 +25,7 @@ export async function main() {
         fs.writeFileSync(pathJoin(buildOptions.keycloakifyBuildDirPath, ".gitignore"), Buffer.from("*", "utf8"));
     }
 
-    const { doesImplementAccountTheme } = await generateTheme({
-        themeSrcDirPath,
-        "keycloakifySrcDirPath": pathJoin(getThisCodebaseRootDirPath(), "src"),
-        "keycloakifyVersion": readThisNpmProjectVersion(),
-        buildOptions
-    });
+    await generateSrcMainResources({ buildOptions });
 
     run_post_build_script: {
         if (buildOptions.bundler !== "vite") {
@@ -45,56 +36,17 @@ export async function main() {
             "cwd": buildOptions.reactAppRootDirPath,
             "env": {
                 ...process.env,
-                [keycloakifyBuildOptionsForPostPostBuildScriptEnvName]: JSON.stringify(buildOptions)
+                [vitePluginSubScriptEnvNames.runPostBuildScript]: JSON.stringify(buildOptions)
             }
         });
     }
 
-    const { lastJarFileBasename } = await buildJars({
-        doesImplementAccountTheme,
-        buildOptions
-    });
-
-    generateStartKeycloakTestingContainer({
-        "jarFilePath": pathJoin(buildOptions.keycloakifyBuildDirPath, lastJarFileBasename),
-        doesImplementAccountTheme,
-        buildOptions
-    });
+    await buildJars({ buildOptions });
 
     logger.log(
-        [
-            `✅ Your keycloak theme has been generated and bundled into .${pathSep}${pathJoin(
-                pathRelative(buildOptions.reactAppRootDirPath, buildOptions.keycloakifyBuildDirPath),
-                "keycloak-theme-for-kc-*.jar"
-            )}`,
-            "",
-            `To test your theme locally you can spin up a Keycloak container image with the theme pre loaded by running:`,
-            "",
-            `👉 $ .${pathSep}${pathRelative(
-                buildOptions.reactAppRootDirPath,
-                pathJoin(buildOptions.keycloakifyBuildDirPath, generateStartKeycloakTestingContainer.basename)
-            )} 👈`,
-            ``,
-            `Once your container is up and running: `,
-            "- Log into the admin console 👉 http://localhost:8080/admin username: admin, password: admin 👈",
-            `- Create a realm:                       Master         -> AddRealm   -> Name: myrealm`,
-            `- Enable registration:                  Realm settings -> Login tab  -> User registration: on`,
-            `- Enable the Account theme (optional):  Realm settings -> Themes tab -> Account theme: ${buildOptions.themeNames[0]}`,
-            `                                        Clients        -> account    -> Login theme:   ${buildOptions.themeNames[0]}`,
-            `- Enable the email theme (optional):    Realm settings -> Themes tab -> Email theme:   ${buildOptions.themeNames[0]} (option will appear only if you have ran npx initialize-email-theme)`,
-            `- Create a client                       Clients        -> Create     -> Client ID:                       myclient`,
-            `                                                                        Root URL:                        https://www.keycloak.org/app/`,
-            `                                                                        Valid redirect URIs:             https://www.keycloak.org/app* http://localhost* (localhost is optional)`,
-            `                                                                        Valid post logout redirect URIs: https://www.keycloak.org/app* http://localhost*`,
-            `                                                                        Web origins:                     *`,
-            `                                                                        Login Theme:                     ${buildOptions.themeNames[0]}`,
-            `                                                                        Save (button at the bottom of the page)`,
-            ``,
-            `- Go to  👉  https://www.keycloak.org/app/ 👈 Click "Save" then "Sign in". You should see your login page`,
-            `- Got to 👉  http://localhost:8080/realms/myrealm/account 👈 to see your account theme`,
-            ``,
-            `Video tutorial: https://youtu.be/WMyGZNHQkjU`,
-            ``
-        ].join("\n")
+        `✅ Your keycloak theme has been generated and bundled into .${pathSep}${pathJoin(
+            pathRelative(process.cwd(), buildOptions.keycloakifyBuildDirPath),
+            "keycloak-theme-for-kc-*.jar"
+        )}`
     );
 }

package/src/bin/keycloakify/replacers/replaceImportsInCssCode.ts

@@ -1,7 +1,7 @@
 import * as crypto from "crypto";
-import type { BuildOptions } from "../buildOptions";
+import type { BuildOptions } from "../../shared/buildOptions";
 import { assert } from "tsafe/assert";
-import { basenameOfTheKeycloakifyResourcesDir } from "../../constants";
+import { basenameOfTheKeycloakifyResourcesDir } from "../../shared/constants";
 
 export type BuildOptionsLike = {
     urlPathname: string | undefined;

package/src/bin/keycloakify/replacers/replaceImportsInInlineCssCode.ts

@@ -1,6 +1,6 @@
-import type { BuildOptions } from "../buildOptions";
+import type { BuildOptions } from "../../shared/buildOptions";
 import { assert } from "tsafe/assert";
-import { basenameOfTheKeycloakifyResourcesDir } from "../../constants";
+import { basenameOfTheKeycloakifyResourcesDir } from "../../shared/constants";
 
 export type BuildOptionsLike = {
     urlPathname: string | undefined;

package/src/bin/keycloakify/replacers/replaceImportsInJsCode/replaceImportsInJsCode.ts

@@ -1,5 +1,5 @@
 import { assert } from "tsafe/assert";
-import type { BuildOptions } from "../../buildOptions";
+import type { BuildOptions } from "../../../shared/buildOptions";
 import { replaceImportsInJsCode_vite } from "./vite";
 import { replaceImportsInJsCode_webpack } from "./webpack";
 import * as fs from "fs";

package/src/bin/keycloakify/replacers/replaceImportsInJsCode/vite.ts

@@ -1,6 +1,6 @@
-import { nameOfTheGlobal, basenameOfTheKeycloakifyResourcesDir } from "../../../constants";
+import { nameOfTheGlobal, basenameOfTheKeycloakifyResourcesDir } from "../../../shared/constants";
 import { assert } from "tsafe/assert";
-import type { BuildOptions } from "../../buildOptions";
+import type { BuildOptions } from "../../../shared/buildOptions";
 import * as nodePath from "path";
 import { replaceAll } from "../../../tools/String.prototype.replaceAll";
 

package/src/bin/keycloakify/replacers/replaceImportsInJsCode/webpack.ts

@@ -1,6 +1,6 @@
-import { nameOfTheGlobal, basenameOfTheKeycloakifyResourcesDir } from "../../../constants";
+import { nameOfTheGlobal, basenameOfTheKeycloakifyResourcesDir } from "../../../shared/constants";
 import { assert } from "tsafe/assert";
-import type { BuildOptions } from "../../buildOptions";
+import type { BuildOptions } from "../../../shared/buildOptions";
 import * as nodePath from "path";
 import { replaceAll } from "../../../tools/String.prototype.replaceAll";
 

package/src/bin/main.ts

@@ -0,0 +1,151 @@
+#!/usr/bin/env node
+
+import { termost } from "termost";
+import * as child_process from "child_process";
+
+export type CliCommandOptions = {
+    isSilent: boolean;
+    reactAppRootDirPath: string | undefined;
+};
+
+const program = termost<CliCommandOptions>("Keycloak theme builder");
+
+const optionsKeys: string[] = [];
+
+program
+    .option({
+        "key": "reactAppRootDirPath",
+        "name": (() => {
+            const long = "project";
+            const short = "p";
+
+            optionsKeys.push(long, short);
+
+            return { long, short };
+        })(),
+        "description": "https://docs.keycloakify.dev/build-options#project-or-p-cli-option",
+        "defaultValue": undefined
+    })
+    .option({
+        "key": "isSilent",
+        "name": (() => {
+            const name = "silent";
+
+            optionsKeys.push(name);
+
+            return name;
+        })(),
+        "description": "https://docs.keycloakify.dev/build-options#silent",
+        "defaultValue": false
+    });
+
+function skip(_context: any, argv: { options: Record<string, unknown> }) {
+    const unrecognizedOptionKey = Object.keys(argv.options).find(key => !optionsKeys.includes(key));
+
+    if (unrecognizedOptionKey !== undefined) {
+        console.error(`keycloakify: Unrecognized option: ${unrecognizedOptionKey.length === 1 ? "-" : "--"}${unrecognizedOptionKey}`);
+        process.exit(1);
+    }
+
+    return false;
+}
+
+async function runAndLogErrors(fn: () => Promise<void>) {
+    try {
+        await fn();
+    } catch (error) {
+        console.error(error);
+        process.exit(1);
+    }
+}
+
+program
+    .command({
+        "name": "build",
+        "description": "Build the theme (default subcommand)."
+    })
+    .task({
+        skip,
+        "handler": async cliCommandOptions => {
+            const { command } = await import("./keycloakify");
+            await runAndLogErrors(() => command({ cliCommandOptions }));
+        }
+    });
+
+program
+    .command({
+        "name": "download-builtin-keycloak-theme",
+        "description": "Download the built-in Keycloak theme."
+    })
+    .task({
+        skip,
+        "handler": async cliCommandOptions => {
+            const { command } = await import("./download-builtin-keycloak-theme");
+            await runAndLogErrors(() => command({ cliCommandOptions }));
+        }
+    });
+
+program
+    .command({
+        "name": "eject-keycloak-page",
+        "description": "Eject a Keycloak page."
+    })
+    .task({
+        skip,
+        "handler": async cliCommandOptions => {
+            const { command } = await import("./eject-keycloak-page");
+            await runAndLogErrors(() => command({ cliCommandOptions }));
+        }
+    });
+
+program
+    .command({
+        "name": "initialize-email-theme",
+        "description": "Initialize an email theme."
+    })
+    .task({
+        skip,
+        "handler": async cliCommandOptions => {
+            const { command } = await import("./initialize-email-theme");
+            await runAndLogErrors(() => command({ cliCommandOptions }));
+        }
+    });
+
+program
+    .command({
+        "name": "start-keycloak-container",
+        "description": "Spin up a Keycloak container with the theme preloaded and the realm pre configured."
+    })
+    .task({
+        skip,
+        "handler": async cliCommandOptions => {
+            const { command } = await import("./start-keycloak-container");
+            await runAndLogErrors(() => command({ cliCommandOptions }));
+        }
+    });
+
+program
+    .command({
+        "name": "copy-keycloak-resources-to-public",
+        "description": "(Webpack/Create-React-App only) Copy Keycloak default theme resources to the public directory."
+    })
+    .task({
+        skip,
+        "handler": async cliCommandOptions => {
+            const { command } = await import("./copy-keycloak-resources-to-public");
+            await runAndLogErrors(() => command({ cliCommandOptions }));
+        }
+    });
+
+// Fallback to build command if no command is provided
+{
+    const [, , ...rest] = process.argv;
+
+    if (rest.length === 0 || (rest[0].startsWith("-") && rest[0] !== "--help" && rest[0] !== "-h")) {
+        const { status } = child_process.spawnSync("npx", ["keycloakify", "build", ...rest], {
+            "stdio": "inherit"
+        });
+
+        process.exit(status ?? 1);
+    }
+}

package/src/bin/shared/KeycloakVersionRange.ts

@@ -0,0 +1,7 @@
+export type KeycloakVersionRange = KeycloakVersionRange.WithAccountTheme | KeycloakVersionRange.WithoutAccountTheme;
+
+export namespace KeycloakVersionRange {
+    export type WithoutAccountTheme = "21-and-below" | "22-and-above";
+
+    export type WithAccountTheme = "21-and-below" | "23" | "24-and-above";
+}

package/src/bin/{keycloakify/buildOptions → shared}/buildOptions.ts

@@ -1,13 +1,13 @@
 import { parse as urlParse } from "url";
-import { readParsedPackageJson } from "./parsedPackageJson";
 import { join as pathJoin } from "path";
-import parseArgv from "minimist";
-import { getAbsoluteAndInOsFormatPath } from "../../tools/getAbsoluteAndInOsFormatPath";
-import { readResolvedViteConfig } from "./resolvedViteConfig";
+import { getAbsoluteAndInOsFormatPath } from "../tools/getAbsoluteAndInOsFormatPath";
+import { getNpmWorkspaceRootDirPath } from "../tools/getNpmWorkspaceRootDirPath";
+import type { CliCommandOptions } from "../main";
+import { z } from "zod";
 import * as fs from "fs";
-import { getCacheDirPath } from "./getCacheDirPath";
-import { getReactAppRootDirPath } from "./getReactAppRootDirPath";
-import { getNpmWorkspaceRootDirPath } from "./getNpmWorkspaceRootDirPath";
+import { assert } from "tsafe";
+import * as child_process from "child_process";
+import { vitePluginSubScriptEnvNames } from "./constants";
 
 /** Consolidated build option gathered form CLI arguments and config in package.json */
 export type BuildOptions = {
@@ -20,6 +20,7 @@ export type BuildOptions = {
     artifactId: string;
     loginThemeResourcesFromKeycloakVersion: string;
     reactAppRootDirPath: string;
+    // TODO: Remove from vite type
     reactAppBuildDirPath: string;
     /** Directory that keycloakify outputs to. Defaults to {cwd}/build_keycloak */
     keycloakifyBuildDirPath: string;
@@ -32,23 +33,98 @@ export type BuildOptions = {
     npmWorkspaceRootDirPath: string;
 };
 
-export function readBuildOptions(params: { processArgv: string[] }): BuildOptions {
-    const { processArgv } = params;
+export type UserProvidedBuildOptions = {
+    extraThemeProperties?: string[];
+    artifactId?: string;
+    groupId?: string;
+    loginThemeResourcesFromKeycloakVersion?: string;
+    keycloakifyBuildDirPath?: string;
+    themeName?: string | string[];
+};
+
+export type ResolvedViteConfig = {
+    buildDir: string;
+    publicDir: string;
+    assetsDir: string;
+    urlPathname: string | undefined;
+    userProvidedBuildOptions: UserProvidedBuildOptions;
+};
+
+export function readBuildOptions(params: { cliCommandOptions: CliCommandOptions }): BuildOptions {
+    const { cliCommandOptions } = params;
+
+    const reactAppRootDirPath = (() => {
+        if (cliCommandOptions.reactAppRootDirPath === undefined) {
+            return process.cwd();
+        }
+
+        return getAbsoluteAndInOsFormatPath({
+            "pathIsh": cliCommandOptions.reactAppRootDirPath,
+            "cwd": process.cwd()
+        });
+    })();
+
+    const { resolvedViteConfig } = (() => {
+        if (fs.readdirSync(reactAppRootDirPath).find(fileBasename => fileBasename.startsWith("vite.config")) === undefined) {
+            return { "resolvedViteConfig": undefined };
+        }
+
+        const output = child_process
+            .execSync("npx vite", {
+                "cwd": reactAppRootDirPath,
+                "env": {
+                    ...process.env,
+                    [vitePluginSubScriptEnvNames.resolveViteConfig]: "true"
+                }
+            })
+            .toString("utf8");
+
+        assert(output.includes(vitePluginSubScriptEnvNames.resolveViteConfig), "Seems like the Keycloakify's Vite plugin is not installed.");
+
+        const resolvedViteConfigStr = output.split(vitePluginSubScriptEnvNames.resolveViteConfig).reverse()[0];
 
-    const { reactAppRootDirPath } = getReactAppRootDirPath({ processArgv });
+        const resolvedViteConfig: ResolvedViteConfig = JSON.parse(resolvedViteConfigStr);
 
-    const { cacheDirPath } = getCacheDirPath({ reactAppRootDirPath });
+        return { resolvedViteConfig };
+    })();
+
+    const parsedPackageJson = (() => {
+        type ParsedPackageJson = {
+            name: string;
+            version?: string;
+            homepage?: string;
+            keycloakify?: UserProvidedBuildOptions & { reactAppBuildDirPath?: string };
+        };
 
-    const { resolvedViteConfig } = readResolvedViteConfig({ cacheDirPath });
+        const zParsedPackageJson = z.object({
+            "name": z.string(),
+            "version": z.string().optional(),
+            "homepage": z.string().optional(),
+            "keycloakify": z
+                .object({
+                    "extraThemeProperties": z.array(z.string()).optional(),
+                    "artifactId": z.string().optional(),
+                    "groupId": z.string().optional(),
+                    "loginThemeResourcesFromKeycloakVersion": z.string().optional(),
+                    "reactAppBuildDirPath": z.string().optional(),
+                    "keycloakifyBuildDirPath": z.string().optional(),
+                    "themeName": z.union([z.string(), z.array(z.string())]).optional()
+                })
+                .optional()
+        });
 
-    if (resolvedViteConfig === undefined && fs.existsSync(pathJoin(reactAppRootDirPath, "vite.config.ts"))) {
-        throw new Error("Keycloakify's Vite plugin output not found");
-    }
+        {
+            type Got = ReturnType<(typeof zParsedPackageJson)["parse"]>;
+            type Expected = ParsedPackageJson;
+            assert<Got extends Expected ? true : false>();
+            assert<Expected extends Got ? true : false>();
+        }
 
-    const { keycloakify: userProvidedBuildOptionsFromPackageJson, ...parsedPackageJson } = readParsedPackageJson({ reactAppRootDirPath });
+        return zParsedPackageJson.parse(JSON.parse(fs.readFileSync(pathJoin(reactAppRootDirPath, "package.json")).toString("utf8")));
+    })();
 
-    const userProvidedBuildOptions = {
-        ...userProvidedBuildOptionsFromPackageJson,
+    const userProvidedBuildOptions: UserProvidedBuildOptions = {
+        ...parsedPackageJson.keycloakify,
         ...resolvedViteConfig?.userProvidedBuildOptions
     };
 
@@ -75,9 +151,9 @@ export function readBuildOptions(params: { processArgv: string[] }): BuildOption
                 break webpack;
             }
 
-            if (userProvidedBuildOptions.reactAppBuildDirPath !== undefined) {
+            if (parsedPackageJson.keycloakify?.reactAppBuildDirPath !== undefined) {
                 return getAbsoluteAndInOsFormatPath({
-                    "pathIsh": userProvidedBuildOptions.reactAppBuildDirPath,
+                    "pathIsh": parsedPackageJson.keycloakify.reactAppBuildDirPath,
                     "cwd": reactAppRootDirPath
                 });
             }
@@ -88,13 +164,11 @@ export function readBuildOptions(params: { processArgv: string[] }): BuildOption
         return pathJoin(reactAppRootDirPath, resolvedViteConfig.buildDir);
     })();
 
-    const argv = parseArgv(processArgv);
-
     const { npmWorkspaceRootDirPath } = getNpmWorkspaceRootDirPath({ reactAppRootDirPath });
 
     return {
         "bundler": resolvedViteConfig !== undefined ? "vite" : "webpack",
-        "isSilent": typeof argv["silent"] === "boolean" ? argv["silent"] : false,
+        "isSilent": cliCommandOptions.isSilent,
         "themeVersion": process.env.KEYCLOAKIFY_THEME_VERSION ?? parsedPackageJson.version ?? "0.0.0",
         themeNames,
         "extraThemeProperties": userProvidedBuildOptions.extraThemeProperties,
@@ -148,7 +222,23 @@ export function readBuildOptions(params: { processArgv: string[] }): BuildOption
 
             return pathJoin(reactAppRootDirPath, resolvedViteConfig.publicDir);
         })(),
-        cacheDirPath,
+        "cacheDirPath": (() => {
+            const cacheDirPath = pathJoin(
+                (() => {
+                    if (process.env.XDG_CACHE_HOME !== undefined) {
+                        return getAbsoluteAndInOsFormatPath({
+                            "pathIsh": process.env.XDG_CACHE_HOME,
+                            "cwd": reactAppRootDirPath
+                        });
+                    }
+
+                    return pathJoin(npmWorkspaceRootDirPath, "node_modules", ".cache");
+                })(),
+                "keycloakify"
+            );
+
+            return cacheDirPath;
+        })(),
         "urlPathname": (() => {
             webpack: {
                 if (resolvedViteConfig !== undefined) {

package/src/bin/{constants.ts → shared/constants.ts}

@@ -2,7 +2,6 @@ export const nameOfTheGlobal = "kcContext";
 export const keycloak_resources = "keycloak-resources";
 export const resources_common = "resources-common";
 export const lastKeycloakVersionWithAccountV1 = "21.1.2";
-export const resolvedViteConfigJsonBasename = "vite.json";
 export const basenameOfTheKeycloakifyResourcesDir = "build";
 
 export const themeTypes = ["login", "account"] as const;
@@ -10,4 +9,7 @@ export const accountV1ThemeName = "account-v1";
 
 export type ThemeType = (typeof themeTypes)[number];
 
-export const keycloakifyBuildOptionsForPostPostBuildScriptEnvName = "KEYCLOAKIFY_BUILD_OPTIONS_POST_POST_BUILD_SCRIPT";
+export const vitePluginSubScriptEnvNames = {
+    "runPostBuildScript": "KEYCLOAKIFY_RUN_POST_BUILD_SCRIPT",
+    "resolveViteConfig": "KEYCLOAKIFY_RESOLVE_VITE_CONFIG"
+} as const;