keycloakify 9.4.0-rc.9 → 9.4.1

package/src/account/i18n/baseMessages/index.ts

@@ -1,16 +1,17 @@
 //This code was automatically generated by running scripts/generate-i18n-messages.ts
 //PLEASE DO NOT EDIT MANUALLY
+import * as en from "./en";
 
 export async function getMessages(currentLanguageTag: string) {
     const { default: messages } = await (() => {
         switch (currentLanguageTag) {
+            case "en": return en;
             case "ar": return import("./ar");
             case "ca": return import("./ca");
             case "cs": return import("./cs");
             case "da": return import("./da");
             case "de": return import("./de");
             case "el": return import("./el");
-            case "en": return import("./en");
             case "es": return import("./es");
             case "fa": return import("./fa");
             case "fi": return import("./fi");

package/src/account/pages/PageProps.ts

@@ -1,10 +1,11 @@
 import type { I18n } from "keycloakify/account/i18n";
 import type { TemplateProps, ClassKey } from "keycloakify/account/TemplateProps";
 import type { LazyOrNot } from "keycloakify/tools/LazyOrNot";
+import type { KcContext } from "keycloakify/account/kcContext";
 
-export type PageProps<KcContext, I18nExtended extends I18n> = {
+export type PageProps<NarowedKcContext = KcContext, I18nExtended extends I18n = I18n> = {
     Template: LazyOrNot<(props: TemplateProps<any, any>) => JSX.Element | null>;
-    kcContext: KcContext;
+    kcContext: NarowedKcContext;
     i18n: I18nExtended;
     doUseDefaultCss: boolean;
     classes?: Partial<Record<ClassKey, string>>;

package/src/bin/constants.ts

@@ -2,7 +2,7 @@ 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 = ".keycloakifyViteConfig.json";
+export const resolvedViteConfigJsonBasename = "vite.json";
 export const basenameOfTheKeycloakifyResourcesDir = "build";
 
 export const themeTypes = ["login", "account"] as const;

package/src/bin/copy-keycloak-resources-to-public.ts

@@ -1,17 +1,44 @@
 #!/usr/bin/env node
 
-import { downloadKeycloakStaticResources } from "./keycloakify/generateTheme/downloadKeycloakStaticResources";
+import { downloadKeycloakStaticResources, type BuildOptionsLike } from "./keycloakify/generateTheme/downloadKeycloakStaticResources";
 import { join as pathJoin, relative as pathRelative } from "path";
 import { readBuildOptions } from "./keycloakify/buildOptions";
 import { themeTypes, keycloak_resources, lastKeycloakVersionWithAccountV1 } from "./constants";
+import { readThisNpmProjectVersion } from "./tools/readThisNpmProjectVersion";
+import { assert, type Equals } from "tsafe/assert";
 import * as fs from "fs";
+import { rmSync } from "./tools/fs.rmSync";
 
-(async () => {
-    const buildOptions = readBuildOptions({
-        "processArgv": process.argv.slice(2)
+export async function copyKeycloakResourcesToPublic(params: { processArgv: string[] }) {
+    const { processArgv } = params;
+
+    const buildOptions = readBuildOptions({ processArgv });
+
+    const destDirPath = pathJoin(buildOptions.publicDirPath, keycloak_resources);
+
+    const keycloakifyBuildinfoFilePath = pathJoin(destDirPath, "keycloakify.buildinfo");
+
+    const { keycloakifyBuildinfoRaw } = generateKeycloakifyBuildinfoRaw({
+        destDirPath,
+        "keycloakifyVersion": readThisNpmProjectVersion(),
+        buildOptions
     });
 
-    const reservedDirPath = pathJoin(buildOptions.publicDirPath, keycloak_resources);
+    skip_if_already_done: {
+        if (!fs.existsSync(keycloakifyBuildinfoFilePath)) {
+            break skip_if_already_done;
+        }
+
+        const keycloakifyBuildinfoRaw_previousRun = fs.readFileSync(keycloakifyBuildinfoFilePath).toString("utf8");
+
+        if (keycloakifyBuildinfoRaw_previousRun !== keycloakifyBuildinfoRaw) {
+            break skip_if_already_done;
+        }
+
+        return;
+    }
+
+    rmSync(destDirPath, { "force": true, "recursive": true });
 
     for (const themeType of themeTypes) {
         await downloadKeycloakStaticResources({
@@ -24,13 +51,13 @@ import * as fs from "fs";
                 }
             })(),
             themeType,
-            "themeDirPath": reservedDirPath,
+            "themeDirPath": destDirPath,
             buildOptions
         });
     }
 
     fs.writeFileSync(
-        pathJoin(reservedDirPath, "README.txt"),
+        pathJoin(destDirPath, "README.txt"),
         Buffer.from(
             // prettier-ignore
             [
@@ -42,5 +69,44 @@ import * as fs from "fs";
 
     fs.writeFileSync(pathJoin(buildOptions.publicDirPath, keycloak_resources, ".gitignore"), Buffer.from("*", "utf8"));
 
-    console.log(`${pathRelative(buildOptions.reactAppRootDirPath, reservedDirPath)} directory created.`);
-})();
+    fs.writeFileSync(keycloakifyBuildinfoFilePath, Buffer.from(keycloakifyBuildinfoRaw, "utf8"));
+}
+
+export function generateKeycloakifyBuildinfoRaw(params: {
+    destDirPath: string;
+    keycloakifyVersion: string;
+    buildOptions: BuildOptionsLike & {
+        loginThemeResourcesFromKeycloakVersion: string;
+    };
+}) {
+    const { destDirPath, keycloakifyVersion, buildOptions } = params;
+
+    const { cacheDirPath, npmWorkspaceRootDirPath, loginThemeResourcesFromKeycloakVersion, ...rest } = buildOptions;
+
+    assert<Equals<typeof rest, {}>>(true);
+
+    const keycloakifyBuildinfoRaw = JSON.stringify(
+        {
+            keycloakifyVersion,
+            "buildOptions": {
+                loginThemeResourcesFromKeycloakVersion,
+                "cacheDirPath": pathRelative(destDirPath, cacheDirPath),
+                "npmWorkspaceRootDirPath": pathRelative(destDirPath, npmWorkspaceRootDirPath)
+            }
+        },
+        null,
+        2
+    );
+
+    return { keycloakifyBuildinfoRaw };
+}
+
+async function main() {
+    await copyKeycloakResourcesToPublic({
+        "processArgv": process.argv.slice(2)
+    });
+}
+
+if (require.main === module) {
+    main();
+}

package/src/bin/download-builtin-keycloak-theme.ts

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 import { join as pathJoin } from "path";
-import { downloadAndUnzip } from "./tools/downloadAndUnzip";
+import { downloadAndUnzip } from "./downloadAndUnzip";
 import { promptKeycloakVersion } from "./promptKeycloakVersion";
 import { getLogger } from "./tools/logger";
 import { readBuildOptions, type BuildOptions } from "./keycloakify/buildOptions";
@@ -13,6 +13,7 @@ import { transformCodebase } from "./tools/transformCodebase";
 
 export type BuildOptionsLike = {
     cacheDirPath: string;
+    npmWorkspaceRootDirPath: string;
 };
 
 assert<BuildOptions extends BuildOptionsLike ? true : false>();
@@ -21,11 +22,10 @@ export async function downloadBuiltinKeycloakTheme(params: { keycloakVersion: st
     const { keycloakVersion, destDirPath, buildOptions } = params;
 
     await downloadAndUnzip({
-        "doUseCache": true,
-        "cacheDirPath": buildOptions.cacheDirPath,
         destDirPath,
         "url": `https://github.com/keycloak/keycloak/archive/refs/tags/${keycloakVersion}.zip`,
         "specificDirsToExtract": ["", "-community"].map(ext => `keycloak-${keycloakVersion}/themes/src/main/resources${ext}/theme`),
+        buildOptions,
         "preCacheTransform": {
             "actionCacheId": "npm install and build",
             "action": async ({ destDirPath }) => {

package/src/bin/downloadAndUnzip.ts

@@ -0,0 +1,203 @@
+import { createHash } from "crypto";
+import { mkdir, writeFile, unlink } from "fs/promises";
+import fetch from "make-fetch-happen";
+import { dirname as pathDirname, join as pathJoin, basename as pathBasename } from "path";
+import { assert } from "tsafe/assert";
+import { transformCodebase } from "./tools/transformCodebase";
+import { unzip, zip } from "./tools/unzip";
+import { rm } from "./tools/fs.rm";
+import * as child_process from "child_process";
+import { existsAsync } from "./tools/fs.existsAsync";
+import type { BuildOptions } from "./keycloakify/buildOptions";
+import { getProxyFetchOptions } from "./tools/fetchProxyOptions";
+
+export type BuildOptionsLike = {
+    cacheDirPath: string;
+    npmWorkspaceRootDirPath: string;
+};
+
+assert<BuildOptions extends BuildOptionsLike ? true : false>();
+
+export async function downloadAndUnzip(params: {
+    url: string;
+    destDirPath: string;
+    specificDirsToExtract?: string[];
+    preCacheTransform?: {
+        actionCacheId: string;
+        action: (params: { destDirPath: string }) => Promise<void>;
+    };
+    buildOptions: BuildOptionsLike;
+}) {
+    const { url, destDirPath, specificDirsToExtract, preCacheTransform, buildOptions } = params;
+
+    const { extractDirPath, zipFilePath } = (() => {
+        const zipFileBasenameWithoutExt = generateFileNameFromURL({
+            url,
+            "preCacheTransform":
+                preCacheTransform === undefined
+                    ? undefined
+                    : {
+                          "actionCacheId": preCacheTransform.actionCacheId,
+                          "actionFootprint": preCacheTransform.action.toString()
+                      }
+        });
+
+        const zipFilePath = pathJoin(buildOptions.cacheDirPath, `${zipFileBasenameWithoutExt}.zip`);
+        const extractDirPath = pathJoin(buildOptions.cacheDirPath, `tmp_unzip_${zipFileBasenameWithoutExt}`);
+
+        return { zipFilePath, extractDirPath };
+    })();
+
+    download_zip_and_transform: {
+        if (await existsAsync(zipFilePath)) {
+            break download_zip_and_transform;
+        }
+
+        const { response, isFromRemoteCache } = await (async () => {
+            const proxyFetchOptions = await getProxyFetchOptions({
+                "npmWorkspaceRootDirPath": buildOptions.npmWorkspaceRootDirPath
+            });
+
+            const response = await fetch(
+                `https://github.com/keycloakify/keycloakify/releases/download/v0.0.1/${pathBasename(zipFilePath)}`,
+                proxyFetchOptions
+            );
+
+            if (response.status === 200) {
+                return {
+                    response,
+                    "isFromRemoteCache": true
+                };
+            }
+
+            return {
+                "response": await fetch(url, proxyFetchOptions),
+                "isFromRemoteCache": false
+            };
+        })();
+
+        await mkdir(pathDirname(zipFilePath), { "recursive": true });
+
+        /**
+         * The correct way to fix this is to upgrade node-fetch beyond 3.2.5
+         * (see https://github.com/node-fetch/node-fetch/issues/1295#issuecomment-1144061991.)
+         * Unfortunately, octokit (a dependency of keycloakify) also uses node-fetch, and
+         * does not support node-fetch 3.x. So we stick around with this band-aid until
+         * octokit upgrades.
+         */
+        response.body?.setMaxListeners(Number.MAX_VALUE);
+        assert(typeof response.body !== "undefined" && response.body != null);
+
+        await writeFile(zipFilePath, response.body);
+
+        if (isFromRemoteCache) {
+            break download_zip_and_transform;
+        }
+
+        if (specificDirsToExtract === undefined && preCacheTransform === undefined) {
+            break download_zip_and_transform;
+        }
+
+        await unzip(zipFilePath, extractDirPath, specificDirsToExtract);
+
+        try {
+            await preCacheTransform?.action({
+                "destDirPath": extractDirPath
+            });
+        } catch (error) {
+            await Promise.all([rm(extractDirPath, { "recursive": true }), unlink(zipFilePath)]);
+
+            throw error;
+        }
+
+        await unlink(zipFilePath);
+
+        await zip(extractDirPath, zipFilePath);
+
+        await rm(extractDirPath, { "recursive": true });
+
+        upload_to_remot_cache_if_admin: {
+            const githubToken = process.env["KEYCLOAKIFY_ADMIN_GITHUB_PERSONAL_ACCESS_TOKEN"];
+
+            if (githubToken === undefined) {
+                break upload_to_remot_cache_if_admin;
+            }
+
+            console.log("uploading to remote cache");
+
+            try {
+                child_process.execSync(`which putasset`);
+            } catch {
+                child_process.execSync(`npm install -g putasset`);
+            }
+
+            try {
+                child_process.execFileSync("putasset", [
+                    "--owner",
+                    "keycloakify",
+                    "--repo",
+                    "keycloakify",
+                    "--tag",
+                    "v0.0.1",
+                    "--filename",
+                    zipFilePath,
+                    "--token",
+                    githubToken
+                ]);
+            } catch {
+                console.log("upload failed, asset probably already exists in remote cache");
+            }
+        }
+    }
+
+    await unzip(zipFilePath, extractDirPath);
+
+    transformCodebase({
+        "srcDirPath": extractDirPath,
+        "destDirPath": destDirPath
+    });
+
+    await rm(extractDirPath, { "recursive": true });
+}
+
+function generateFileNameFromURL(params: {
+    url: string;
+    preCacheTransform:
+        | {
+              actionCacheId: string;
+              actionFootprint: string;
+          }
+        | undefined;
+}): string {
+    const { preCacheTransform } = params;
+
+    // Parse the URL
+    const url = new URL(params.url);
+
+    // Extract pathname and remove leading slashes
+    let fileName = url.pathname.replace(/^\//, "").replace(/\//g, "_");
+
+    // Optionally, add query parameters replacing special characters
+    if (url.search) {
+        fileName += url.search.replace(/[&=?]/g, "-");
+    }
+
+    // Replace any characters that are not valid in filenames
+    fileName = fileName.replace(/[^a-zA-Z0-9-_]/g, "");
+
+    // Trim or pad the fileName to a specific length
+    fileName = fileName.substring(0, 50);
+
+    add_pre_cache_transform: {
+        if (preCacheTransform === undefined) {
+            break add_pre_cache_transform;
+        }
+
+        // Sanitize actionCacheId the same way as other components
+        const sanitizedActionCacheId = preCacheTransform.actionCacheId.replace(/[^a-zA-Z0-9-_]/g, "_");
+
+        fileName += `_${sanitizedActionCacheId}_${createHash("sha256").update(preCacheTransform.actionFootprint).digest("hex").substring(0, 5)}`;
+    }
+
+    return fileName;
+}

package/src/bin/eject-keycloak-page.ts

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 
-import { getProjectRoot } from "./tools/getProjectRoot";
+import { getThisCodebaseRootDirPath } from "./tools/getThisCodebaseRootDirPath";
 import cliSelect from "cli-select";
 import { loginThemePageIds, accountThemePageIds, type LoginThemePageId, type AccountThemePageId } from "./keycloakify/generateFtl";
 import { capitalize } from "tsafe/capitalize";
@@ -11,11 +11,14 @@ import { kebabCaseToCamelCase } from "./tools/kebabCaseToSnakeCase";
 import { assert, Equals } from "tsafe/assert";
 import { getThemeSrcDirPath } from "./getThemeSrcDirPath";
 import { themeTypes, type ThemeType } from "./constants";
+import { getReactAppRootDirPath } from "./keycloakify/buildOptions/getReactAppRootDirPath";
 
 (async () => {
     console.log("Select a theme type");
 
-    const reactAppRootDirPath = process.cwd();
+    const { reactAppRootDirPath } = getReactAppRootDirPath({
+        "processArgv": process.argv.slice(2)
+    });
 
     const { value: themeType } = await cliSelect<ThemeType>({
         "values": [...themeTypes]
@@ -55,7 +58,7 @@ import { themeTypes, type ThemeType } from "./constants";
         process.exit(-1);
     }
 
-    await writeFile(targetFilePath, await readFile(pathJoin(getProjectRoot(), "src", themeType, "pages", pageBasename)));
+    await writeFile(targetFilePath, await readFile(pathJoin(getThisCodebaseRootDirPath(), "src", themeType, "pages", pageBasename)));
 
     console.log(`${pathRelative(process.cwd(), targetFilePath)} created`);
 })();

package/src/bin/keycloakify/buildOptions/buildOptions.ts

@@ -4,7 +4,10 @@ import { join as pathJoin } from "path";
 import parseArgv from "minimist";
 import { getAbsoluteAndInOsFormatPath } from "../../tools/getAbsoluteAndInOsFormatPath";
 import { readResolvedViteConfig } from "./resolvedViteConfig";
-import { getKeycloakifyBuildDirPath } from "./getKeycloakifyBuildDirPath";
+import * as fs from "fs";
+import { getCacheDirPath } from "./getCacheDirPath";
+import { getReactAppRootDirPath } from "./getReactAppRootDirPath";
+import { getNpmWorkspaceRootDirPath } from "./getNpmWorkspaceRootDirPath";
 
 /** Consolidated build option gathered form CLI arguments and config in package.json */
 export type BuildOptions = {
@@ -28,34 +31,24 @@ export type BuildOptions = {
     urlPathname: string | undefined;
     assetsDirPath: string;
     doBuildRetrocompatAccountTheme: boolean;
+    npmWorkspaceRootDirPath: string;
 };
 
 export function readBuildOptions(params: { processArgv: string[] }): BuildOptions {
     const { processArgv } = params;
 
-    const argv = parseArgv(processArgv);
+    const { reactAppRootDirPath } = getReactAppRootDirPath({ processArgv });
 
-    const reactAppRootDirPath = (() => {
-        const arg = argv["project"] ?? argv["p"];
+    const { cacheDirPath } = getCacheDirPath({ reactAppRootDirPath });
 
-        if (typeof arg !== "string") {
-            return process.cwd();
-        }
+    const { resolvedViteConfig } = readResolvedViteConfig({ cacheDirPath });
 
-        return getAbsoluteAndInOsFormatPath({
-            "pathIsh": arg,
-            "cwd": process.cwd()
-        });
-    })();
+    if (resolvedViteConfig === undefined && fs.existsSync(pathJoin(reactAppRootDirPath, "vite.config.ts"))) {
+        throw new Error("Keycloakify's Vite plugin output not found");
+    }
 
     const parsedPackageJson = readParsedPackageJson({ reactAppRootDirPath });
 
-    const { resolvedViteConfig } =
-        readResolvedViteConfig({
-            "parsedPackageJson_keycloakify_keycloakifyBuildDirPath": parsedPackageJson.keycloakify?.keycloakifyBuildDirPath,
-            reactAppRootDirPath
-        }) ?? {};
-
     const themeNames = (() => {
         if (parsedPackageJson.keycloakify?.themeName === undefined) {
             return [
@@ -73,12 +66,6 @@ export function readBuildOptions(params: { processArgv: string[] }): BuildOption
         return parsedPackageJson.keycloakify.themeName;
     })();
 
-    const { keycloakifyBuildDirPath } = getKeycloakifyBuildDirPath({
-        "parsedPackageJson_keycloakify_keycloakifyBuildDirPath": parsedPackageJson.keycloakify?.keycloakifyBuildDirPath,
-        reactAppRootDirPath,
-        "bundler": resolvedViteConfig !== undefined ? "vite" : "webpack"
-    });
-
     const reactAppBuildDirPath = (() => {
         webpack: {
             if (resolvedViteConfig !== undefined) {
@@ -98,6 +85,10 @@ 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,
@@ -124,7 +115,16 @@ export function readBuildOptions(params: { processArgv: string[] }): BuildOption
         "loginThemeResourcesFromKeycloakVersion": parsedPackageJson.keycloakify?.loginThemeResourcesFromKeycloakVersion ?? "11.0.3",
         reactAppRootDirPath,
         reactAppBuildDirPath,
-        keycloakifyBuildDirPath,
+        "keycloakifyBuildDirPath": (() => {
+            if (parsedPackageJson.keycloakify?.keycloakifyBuildDirPath !== undefined) {
+                return getAbsoluteAndInOsFormatPath({
+                    "pathIsh": parsedPackageJson.keycloakify?.keycloakifyBuildDirPath,
+                    "cwd": reactAppRootDirPath
+                });
+            }
+
+            return resolvedViteConfig?.buildDir === undefined ? "build_keycloak" : `${resolvedViteConfig.buildDir}_keycloak`;
+        })(),
         "publicDirPath": (() => {
             webpack: {
                 if (resolvedViteConfig !== undefined) {
@@ -143,19 +143,7 @@ export function readBuildOptions(params: { processArgv: string[] }): BuildOption
 
             return pathJoin(reactAppRootDirPath, resolvedViteConfig.publicDir);
         })(),
-        "cacheDirPath": pathJoin(
-            (() => {
-                if (process.env.XDG_CACHE_HOME !== undefined) {
-                    return getAbsoluteAndInOsFormatPath({
-                        "pathIsh": process.env.XDG_CACHE_HOME,
-                        "cwd": reactAppRootDirPath
-                    });
-                }
-
-                return pathJoin(reactAppRootDirPath, "node_modules", ".cache");
-            })(),
-            "keycloakify"
-        ),
+        cacheDirPath,
         "urlPathname": (() => {
             webpack: {
                 if (resolvedViteConfig !== undefined) {
@@ -191,6 +179,7 @@ export function readBuildOptions(params: { processArgv: string[] }): BuildOption
 
             return pathJoin(reactAppBuildDirPath, resolvedViteConfig.assetsDir);
         })(),
-        "doBuildRetrocompatAccountTheme": parsedPackageJson.keycloakify?.doBuildRetrocompatAccountTheme ?? true
+        "doBuildRetrocompatAccountTheme": parsedPackageJson.keycloakify?.doBuildRetrocompatAccountTheme ?? true,
+        npmWorkspaceRootDirPath
     };
 }

package/src/bin/keycloakify/buildOptions/getCacheDirPath.ts

@@ -0,0 +1,25 @@
+import { join as pathJoin } from "path";
+import { getAbsoluteAndInOsFormatPath } from "../../tools/getAbsoluteAndInOsFormatPath";
+import { getNpmWorkspaceRootDirPath } from "./getNpmWorkspaceRootDirPath";
+
+export function getCacheDirPath(params: { reactAppRootDirPath: string }) {
+    const { reactAppRootDirPath } = params;
+
+    const { npmWorkspaceRootDirPath } = getNpmWorkspaceRootDirPath({ reactAppRootDirPath });
+
+    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 };
+}

package/src/bin/keycloakify/buildOptions/getNpmWorkspaceRootDirPath.ts

@@ -0,0 +1,49 @@
+import * as child_process from "child_process";
+import { join as pathJoin, resolve as pathResolve, sep as pathSep } from "path";
+import { assert } from "tsafe/assert";
+
+let cache:
+    | {
+          reactAppRootDirPath: string;
+          npmWorkspaceRootDirPath: string;
+      }
+    | undefined = undefined;
+
+export function getNpmWorkspaceRootDirPath(params: { reactAppRootDirPath: string }) {
+    const { reactAppRootDirPath } = params;
+
+    use_cache: {
+        if (cache === undefined || cache.reactAppRootDirPath !== reactAppRootDirPath) {
+            break use_cache;
+        }
+
+        const { npmWorkspaceRootDirPath } = cache;
+
+        return { npmWorkspaceRootDirPath };
+    }
+
+    const npmWorkspaceRootDirPath = (function callee(depth: number): string {
+        const cwd = pathResolve(pathJoin(...[reactAppRootDirPath, ...Array(depth).fill("..")]));
+
+        try {
+            child_process.execSync("npm config get", { cwd: cwd });
+        } catch (error) {
+            if (String(error).includes("ENOWORKSPACES")) {
+                assert(cwd !== pathSep, "NPM workspace not found");
+
+                return callee(depth + 1);
+            }
+
+            throw error;
+        }
+
+        return cwd;
+    })(0);
+
+    cache = {
+        reactAppRootDirPath,
+        npmWorkspaceRootDirPath
+    };
+
+    return { npmWorkspaceRootDirPath };
+}

package/src/bin/keycloakify/buildOptions/getReactAppRootDirPath.ts

@@ -0,0 +1,23 @@
+import parseArgv from "minimist";
+import { getAbsoluteAndInOsFormatPath } from "../../tools/getAbsoluteAndInOsFormatPath";
+
+export function getReactAppRootDirPath(params: { processArgv: string[] }) {
+    const { processArgv } = params;
+
+    const argv = parseArgv(processArgv);
+
+    const reactAppRootDirPath = (() => {
+        const arg = argv["project"] ?? argv["p"];
+
+        if (typeof arg !== "string") {
+            return process.cwd();
+        }
+
+        return getAbsoluteAndInOsFormatPath({
+            "pathIsh": arg,
+            "cwd": process.cwd()
+        });
+    })();
+
+    return { reactAppRootDirPath };
+}