keycloakify 11.5.0 → 11.5.2

package/bin/682.index.js

@@ -311,7 +311,15 @@ const zParsedRealmJson = (() => {
             })
                 .optional(),
             protocol: lib.z.string().optional(),
-            protocolMappers: lib.z.array(lib.z.unknown()).optional()
+            protocolMappers: lib.z.array(lib.z.object({
+                id: lib.z.string(),
+                name: lib.z.string(),
+                protocol: lib.z.string(),
+                protocolMapper: lib.z.string(),
+                consentRequired: lib.z.boolean(),
+                config: lib.z.record(lib.z.string()).optional()
+            }))
+                .optional()
         }))
     });
     assert/* assert */.h;
@@ -399,12 +407,12 @@ async function getSupportedDockerImageTags(params) {
             return result;
         }
     }
-    const tags = [];
+    const tags_queryResponse = [];
     await (async function callee(url) {
         const r = await lib_default()(url, buildContext.fetchOptions);
         await Promise.all([
             (async () => {
-                tags.push(...lib.z.object({
+                tags_queryResponse.push(...lib.z.object({
                     tags: lib.z.array(lib.z.string())
                 })
                     .parse(await r.json()).tags);
@@ -424,7 +432,8 @@ async function getSupportedDockerImageTags(params) {
             })()
         ]);
     })("https://quay.io/v2/keycloak/keycloak/tags/list");
-    const arr = tags
+    const supportedKeycloakMajorVersions = getSupportedKeycloakMajorVersions();
+    const allSupportedTags_withVersion = tags_queryResponse
         .map(tag => ({
         tag,
         version: (() => {
@@ -438,21 +447,27 @@ async function getSupportedDockerImageTags(params) {
             catch (_a) {
                 return undefined;
             }
+            if (tag.split(".").length !== 3) {
+                return undefined;
+            }
+            if (!supportedKeycloakMajorVersions.includes(version.major)) {
+                return undefined;
+            }
             return version;
         })()
     }))
         .map(({ tag, version }) => (version === undefined ? undefined : { tag, version }))
-        .filter((0,exclude/* exclude */.D)(undefined));
-    const versionByMajor = {};
-    for (const { version } of arr) {
-        const version_current = versionByMajor[version.major];
+        .filter((0,exclude/* exclude */.D)(undefined))
+        .sort(({ version: a }, { version: b }) => SemVer/* SemVer.compare */.h.compare(b, a));
+    const latestTagByMajor = {};
+    for (const { version } of allSupportedTags_withVersion) {
+        const version_current = latestTagByMajor[version.major];
         if (version_current === undefined ||
             SemVer/* SemVer.compare */.h.compare(version_current, version) === -1) {
-            versionByMajor[version.major] = version;
+            latestTagByMajor[version.major] = version;
         }
     }
-    const supportedKeycloakMajorVersions = getSupportedKeycloakMajorVersions();
-    const result = Object.entries(versionByMajor)
+    const latestMajorTags = Object.entries(latestTagByMajor)
         .sort(([a], [b]) => parseInt(b) - parseInt(a))
         .map(([, version]) => version)
         .map(version => {
@@ -463,15 +478,28 @@ async function getSupportedDockerImageTags(params) {
         return SemVer/* SemVer.stringify */.h.stringify(version);
     })
         .filter((0,exclude/* exclude */.D)(undefined));
+    const allSupportedTags = allSupportedTags_withVersion.map(({ tag }) => tag);
+    const result = {
+        latestMajorTags,
+        allSupportedTags
+    };
     await setCachedValue({ cacheDirPath: buildContext.cacheDirPath, result });
     return result;
 }
 const { getCachedValue, setCachedValue } = (() => {
+    const zResult = (() => {
+        const zTargetType = lib.z.object({
+            allSupportedTags: lib.z.array(lib.z.string()),
+            latestMajorTags: lib.z.array(lib.z.string())
+        });
+        assert/* assert */.h;
+        return (0,id.id)(zTargetType);
+    })();
     const zCache = (() => {
         const zTargetType = lib.z.object({
             keycloakifyVersion: lib.z.string(),
             time: lib.z.number(),
-            result: lib.z.array(lib.z.string())
+            result: zResult
         });
         assert/* assert */.h;
         return (0,id.id)(zTargetType);
@@ -705,7 +733,7 @@ function addOrEditClient(params) {
     return { clientId: testClient.clientId };
 }
 function editAccountConsoleAndSecurityAdminConsole(params) {
-    var _a, _b, _c;
+    var _a, _b, _c, _d, _e;
     const { parsedRealmJson } = params;
     for (const clientId of ["account-console", "security-admin-console"]) {
         const client = parsedRealmJson.clients.find(client => client.clientId === clientId);
@@ -721,6 +749,56 @@ function editAccountConsoleAndSecurityAdminConsole(params) {
         }
         ((_c = client.attributes) !== null && _c !== void 0 ? _c : (client.attributes = {}))["post.logout.redirect.uris"] = "+";
         client.webOrigins = ["*"];
+        admin_specific: {
+            if (clientId !== "security-admin-console") {
+                break admin_specific;
+            }
+            const protocolMapper_preexisting = (_d = client.protocolMappers) === null || _d === void 0 ? void 0 : _d.find(protocolMapper => {
+                if (protocolMapper.protocolMapper !== "oidc-hardcoded-claim-mapper") {
+                    return false;
+                }
+                if (protocolMapper.protocol !== "openid-connect") {
+                    return false;
+                }
+                if (protocolMapper.config === undefined) {
+                    return false;
+                }
+                if (protocolMapper.config["claim.name"] !== "allowed-origins") {
+                    return false;
+                }
+                return true;
+            });
+            let protocolMapper;
+            const config = {
+                "introspection.token.claim": "true",
+                "claim.value": '["*"]',
+                "userinfo.token.claim": "true",
+                "id.token.claim": "false",
+                "lightweight.claim": "false",
+                "access.token.claim": "true",
+                "claim.name": "allowed-origins",
+                "jsonType.label": "JSON",
+                "access.tokenResponse.claim": "false"
+            };
+            if (protocolMapper_preexisting !== undefined) {
+                protocolMapper = protocolMapper_preexisting;
+            }
+            else {
+                protocolMapper = {
+                    id: "8fd0d584-7052-4d04-a615-d18a71050873",
+                    name: "allowed-origins",
+                    protocol: "openid-connect",
+                    protocolMapper: "oidc-hardcoded-claim-mapper",
+                    consentRequired: false,
+                    config
+                };
+                ((_e = client.protocolMappers) !== null && _e !== void 0 ? _e : (client.protocolMappers = [])).push(protocolMapper);
+            }
+            (0,assert/* assert */.h)(protocolMapper.config !== undefined);
+            if (config !== protocolMapper.config) {
+                Object.assign(protocolMapper.config, config);
+            }
+        }
     }
 }
 //# sourceMappingURL=prepareRealmConfig.js.map
@@ -735,12 +813,29 @@ function editAccountConsoleAndSecurityAdminConsole(params) {
 (0,assert/* assert */.h)();
 async function dumpContainerConfig(params) {
     const { realmName, keycloakMajorVersionNumber, buildContext } = params;
-    {
-        // https://github.com/keycloak/keycloak/issues/33800
-        const doesUseLockedH2Database = keycloakMajorVersionNumber >= 25;
-        if (doesUseLockedH2Database) {
-            external_child_process_default().execSync(`docker exec ${constants/* CONTAINER_NAME */.sv} sh -c "cp -rp /opt/keycloak/data/h2 /tmp"`);
+    // https://github.com/keycloak/keycloak/issues/33800
+    const doesUseLockedH2Database = keycloakMajorVersionNumber >= 25;
+    if (doesUseLockedH2Database) {
+        const dCompleted = new Deferred.Deferred();
+        const cmd = `docker exec ${constants/* CONTAINER_NAME */.sv} sh -c "cp -rp /opt/keycloak/data/h2 /tmp"`;
+        external_child_process_default().exec(cmd, error => {
+            if (error !== null) {
+                dCompleted.reject(error);
+                return;
+            }
+            dCompleted.resolve();
+        });
+        try {
+            await dCompleted.pr;
+        }
+        catch (error) {
+            (0,assert/* assert */.h)((0,assert.is)(error));
+            console.log(source_default().red(`Docker command failed: ${cmd}`));
+            console.log(source_default().red(error.message));
+            throw error;
         }
+    }
+    {
         const dCompleted = new Deferred.Deferred();
         const child = external_child_process_default().spawn("docker", [
             ...["exec", constants/* CONTAINER_NAME */.sv],
@@ -760,7 +855,7 @@ async function dumpContainerConfig(params) {
         ], { shell: true });
         let output = "";
         const onExit = (code) => {
-            dCompleted.reject(new Error(`Exited with code ${code}`));
+            dCompleted.reject(new Error(`docker exec kc.sh export command failed with code ${code}`));
         };
         child.once("exit", onExit);
         child.stdout.on("data", data => {
@@ -789,31 +884,51 @@ async function dumpContainerConfig(params) {
             (0,assert/* assert */.h)((0,assert.is)(error));
             console.log(source_default().red(error.message));
             console.log(output);
-            process.exit(1);
+            throw error;
         }
-        if (doesUseLockedH2Database) {
-            const dCompleted = new Deferred.Deferred();
-            external_child_process_default().exec(`docker exec ${constants/* CONTAINER_NAME */.sv} sh -c "rm -rf /tmp/h2"`, error => {
-                if (error !== null) {
-                    dCompleted.reject(error);
-                    return;
-                }
-                dCompleted.resolve();
-            });
+    }
+    if (doesUseLockedH2Database) {
+        const dCompleted = new Deferred.Deferred();
+        const cmd = `docker exec ${constants/* CONTAINER_NAME */.sv} sh -c "rm -rf /tmp/h2"`;
+        external_child_process_default().exec(cmd, error => {
+            if (error !== null) {
+                dCompleted.reject(error);
+                return;
+            }
+            dCompleted.resolve();
+        });
+        try {
             await dCompleted.pr;
         }
+        catch (error) {
+            (0,assert/* assert */.h)((0,assert.is)(error));
+            console.log(source_default().red(`Docker command failed: ${cmd}`));
+            console.log(source_default().red(error.message));
+            throw error;
+        }
     }
     const targetRealmConfigJsonFilePath_tmp = (0,external_path_.join)(buildContext.cacheDirPath, "realm.json");
     {
         const dCompleted = new Deferred.Deferred();
-        external_child_process_default().exec(`docker cp ${constants/* CONTAINER_NAME */.sv}:/tmp/${realmName}-realm.json ${targetRealmConfigJsonFilePath_tmp}`, error => {
+        const cmd = `docker cp ${constants/* CONTAINER_NAME */.sv}:/tmp/${realmName}-realm.json ${(0,external_path_.basename)(targetRealmConfigJsonFilePath_tmp)}`;
+        external_child_process_default().exec(cmd, {
+            cwd: (0,external_path_.dirname)(targetRealmConfigJsonFilePath_tmp)
+        }, error => {
             if (error !== null) {
                 dCompleted.reject(error);
                 return;
             }
             dCompleted.resolve();
         });
-        await dCompleted.pr;
+        try {
+            await dCompleted.pr;
+        }
+        catch (error) {
+            (0,assert/* assert */.h)((0,assert.is)(error));
+            console.log(source_default().red(`Docker command failed: ${cmd}`));
+            console.log(source_default().red(error.message));
+            throw error;
+        }
     }
     return readRealmJsonFile({
         realmJsonFilePath: targetRealmConfigJsonFilePath_tmp
@@ -877,11 +992,18 @@ async function getRealmConfig(params) {
         const run = runExclusive.build(async () => {
             const start = Date.now();
             console.log(source_default().grey(`Changes detected to the '${realmName}' config, backing up...`));
-            const parsedRealmJson = await dumpContainerConfig({
-                buildContext,
-                realmName,
-                keycloakMajorVersionNumber
-            });
+            let parsedRealmJson;
+            try {
+                parsedRealmJson = await dumpContainerConfig({
+                    buildContext,
+                    realmName,
+                    keycloakMajorVersionNumber
+                });
+            }
+            catch (error) {
+                console.log(source_default().red(`Failed to backup '${realmName}' config:`));
+                return;
+            }
             await writeRealmJsonFile({ parsedRealmJson });
             console.log([
                 source_default().grey(`Save changed to \`.${external_path_.sep}${(0,external_path_.relative)(buildContext.projectDirPath, realmJsonFilePath)}\``),
@@ -975,13 +1097,13 @@ async function command(params) {
         process.exit(1);
     }
     const { cliCommandOptions, buildContext } = params;
-    const availableTags = await getSupportedDockerImageTags({
+    const { allSupportedTags, latestMajorTags } = await getSupportedDockerImageTags({
         buildContext
     });
     const { dockerImageTag } = await (async () => {
         if (cliCommandOptions.keycloakVersion !== undefined) {
             const cliCommandOptions_keycloakVersion = cliCommandOptions.keycloakVersion;
-            const tag = availableTags.find(tag => tag.startsWith(cliCommandOptions_keycloakVersion));
+            const tag = allSupportedTags.find(tag => tag.startsWith(cliCommandOptions_keycloakVersion));
             if (tag === undefined) {
                 console.log(source_default().red([
                     `We could not find a Keycloak Docker image for ${cliCommandOptions_keycloakVersion}`,
@@ -1001,7 +1123,7 @@ async function command(params) {
             source_default().gray("You can also explicitly provide the version with `npx keycloakify start-keycloak --keycloak-version 26` (or any other version)")
         ].join("\n"));
         const { value: tag } = await dist_default()({
-            values: availableTags
+            values: latestMajorTags
         }).catch(() => {
             process.exit(-1);
         });
@@ -1356,6 +1478,91 @@ async function command(params) {
 
 /***/ }),
 
+/***/ 12171:
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   "h": () => (/* binding */ SemVer)
+/* harmony export */ });
+var SemVer;
+(function (SemVer) {
+    const bumpTypes = ["major", "minor", "patch", "rc", "no bump"];
+    function parse(versionStr) {
+        const match = versionStr.match(/^v?([0-9]+)\.([0-9]+)(?:\.([0-9]+))?(?:-rc.([0-9]+))?$/);
+        if (!match) {
+            throw new Error(`${versionStr} is not a valid semantic version`);
+        }
+        const semVer = Object.assign({ major: parseInt(match[1]), minor: parseInt(match[2]), patch: (() => {
+                const str = match[3];
+                return str === undefined ? 0 : parseInt(str);
+            })() }, (() => {
+            const str = match[4];
+            return str === undefined ? {} : { rc: parseInt(str) };
+        })());
+        const initialStr = stringify(semVer);
+        Object.defineProperty(semVer, "parsedFrom", {
+            enumerable: true,
+            get: function () {
+                const currentStr = stringify(this);
+                if (currentStr !== initialStr) {
+                    throw new Error(`SemVer.parsedFrom can't be read anymore, the version have been modified from ${initialStr} to ${currentStr}`);
+                }
+                return versionStr;
+            }
+        });
+        return semVer;
+    }
+    SemVer.parse = parse;
+    function stringify(v) {
+        return `${v.major}.${v.minor}.${v.patch}${v.rc === undefined ? "" : `-rc.${v.rc}`}`;
+    }
+    SemVer.stringify = stringify;
+    /**
+     *
+     * v1  <  v2  => -1
+     * v1 === v2  => 0
+     * v1  >  v2  => 1
+     *
+     */
+    function compare(v1, v2) {
+        const sign = (diff) => (diff === 0 ? 0 : diff < 0 ? -1 : 1);
+        const noUndefined = (n) => n !== null && n !== void 0 ? n : Infinity;
+        for (const level of ["major", "minor", "patch", "rc"]) {
+            if (noUndefined(v1[level]) !== noUndefined(v2[level])) {
+                return sign(noUndefined(v1[level]) - noUndefined(v2[level]));
+            }
+        }
+        return 0;
+    }
+    SemVer.compare = compare;
+    /*
+    console.log(compare(parse("3.0.0-rc.3"), parse("3.0.0")) === -1 )
+    console.log(compare(parse("3.0.0-rc.3"), parse("3.0.0-rc.4")) === -1 )
+    console.log(compare(parse("3.0.0-rc.3"), parse("4.0.0")) === -1 )
+    */
+    function bumpType(params) {
+        const versionAhead = typeof params.versionAhead === "string"
+            ? parse(params.versionAhead)
+            : params.versionAhead;
+        const versionBehind = typeof params.versionBehind === "string"
+            ? parse(params.versionBehind)
+            : params.versionBehind;
+        if (compare(versionBehind, versionAhead) === 1) {
+            throw new Error(`Version regression ${stringify(versionBehind)} -> ${stringify(versionAhead)}`);
+        }
+        for (const level of ["major", "minor", "patch", "rc"]) {
+            if (versionBehind[level] !== versionAhead[level]) {
+                return level;
+            }
+        }
+        return "no bump";
+    }
+    SemVer.bumpType = bumpType;
+})(SemVer || (SemVer = {}));
+//# sourceMappingURL=SemVer.js.map
+
+/***/ }),
+
 /***/ 38367:
 /***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
 

package/bin/735.index.js

@@ -402,6 +402,91 @@ async function getLatestsSemVersionedTag(_a) {
 
 /***/ }),
 
+/***/ 12171:
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   "h": () => (/* binding */ SemVer)
+/* harmony export */ });
+var SemVer;
+(function (SemVer) {
+    const bumpTypes = ["major", "minor", "patch", "rc", "no bump"];
+    function parse(versionStr) {
+        const match = versionStr.match(/^v?([0-9]+)\.([0-9]+)(?:\.([0-9]+))?(?:-rc.([0-9]+))?$/);
+        if (!match) {
+            throw new Error(`${versionStr} is not a valid semantic version`);
+        }
+        const semVer = Object.assign({ major: parseInt(match[1]), minor: parseInt(match[2]), patch: (() => {
+                const str = match[3];
+                return str === undefined ? 0 : parseInt(str);
+            })() }, (() => {
+            const str = match[4];
+            return str === undefined ? {} : { rc: parseInt(str) };
+        })());
+        const initialStr = stringify(semVer);
+        Object.defineProperty(semVer, "parsedFrom", {
+            enumerable: true,
+            get: function () {
+                const currentStr = stringify(this);
+                if (currentStr !== initialStr) {
+                    throw new Error(`SemVer.parsedFrom can't be read anymore, the version have been modified from ${initialStr} to ${currentStr}`);
+                }
+                return versionStr;
+            }
+        });
+        return semVer;
+    }
+    SemVer.parse = parse;
+    function stringify(v) {
+        return `${v.major}.${v.minor}.${v.patch}${v.rc === undefined ? "" : `-rc.${v.rc}`}`;
+    }
+    SemVer.stringify = stringify;
+    /**
+     *
+     * v1  <  v2  => -1
+     * v1 === v2  => 0
+     * v1  >  v2  => 1
+     *
+     */
+    function compare(v1, v2) {
+        const sign = (diff) => (diff === 0 ? 0 : diff < 0 ? -1 : 1);
+        const noUndefined = (n) => n !== null && n !== void 0 ? n : Infinity;
+        for (const level of ["major", "minor", "patch", "rc"]) {
+            if (noUndefined(v1[level]) !== noUndefined(v2[level])) {
+                return sign(noUndefined(v1[level]) - noUndefined(v2[level]));
+            }
+        }
+        return 0;
+    }
+    SemVer.compare = compare;
+    /*
+    console.log(compare(parse("3.0.0-rc.3"), parse("3.0.0")) === -1 )
+    console.log(compare(parse("3.0.0-rc.3"), parse("3.0.0-rc.4")) === -1 )
+    console.log(compare(parse("3.0.0-rc.3"), parse("4.0.0")) === -1 )
+    */
+    function bumpType(params) {
+        const versionAhead = typeof params.versionAhead === "string"
+            ? parse(params.versionAhead)
+            : params.versionAhead;
+        const versionBehind = typeof params.versionBehind === "string"
+            ? parse(params.versionBehind)
+            : params.versionBehind;
+        if (compare(versionBehind, versionAhead) === 1) {
+            throw new Error(`Version regression ${stringify(versionBehind)} -> ${stringify(versionAhead)}`);
+        }
+        for (const level of ["major", "minor", "patch", "rc"]) {
+            if (versionBehind[level] !== versionAhead[level]) {
+                return level;
+            }
+        }
+        return "no bump";
+    }
+    SemVer.bumpType = bumpType;
+})(SemVer || (SemVer = {}));
+//# sourceMappingURL=SemVer.js.map
+
+/***/ }),
+
 /***/ 89693:
 /***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
 

package/bin/main.js

@@ -96,92 +96,6 @@ const TEST_APP_URL = "https://my-theme.keycloakify.dev";
 
 /***/ }),
 
-/***/ 12171:
-/***/ ((__unused_webpack_module, __webpack_exports__, __nccwpck_require__) => {
-
-"use strict";
-/* harmony export */ __nccwpck_require__.d(__webpack_exports__, {
-/* harmony export */   "h": () => (/* binding */ SemVer)
-/* harmony export */ });
-var SemVer;
-(function (SemVer) {
-    const bumpTypes = ["major", "minor", "patch", "rc", "no bump"];
-    function parse(versionStr) {
-        const match = versionStr.match(/^v?([0-9]+)\.([0-9]+)(?:\.([0-9]+))?(?:-rc.([0-9]+))?$/);
-        if (!match) {
-            throw new Error(`${versionStr} is not a valid semantic version`);
-        }
-        const semVer = Object.assign({ major: parseInt(match[1]), minor: parseInt(match[2]), patch: (() => {
-                const str = match[3];
-                return str === undefined ? 0 : parseInt(str);
-            })() }, (() => {
-            const str = match[4];
-            return str === undefined ? {} : { rc: parseInt(str) };
-        })());
-        const initialStr = stringify(semVer);
-        Object.defineProperty(semVer, "parsedFrom", {
-            enumerable: true,
-            get: function () {
-                const currentStr = stringify(this);
-                if (currentStr !== initialStr) {
-                    throw new Error(`SemVer.parsedFrom can't be read anymore, the version have been modified from ${initialStr} to ${currentStr}`);
-                }
-                return versionStr;
-            }
-        });
-        return semVer;
-    }
-    SemVer.parse = parse;
-    function stringify(v) {
-        return `${v.major}.${v.minor}.${v.patch}${v.rc === undefined ? "" : `-rc.${v.rc}`}`;
-    }
-    SemVer.stringify = stringify;
-    /**
-     *
-     * v1  <  v2  => -1
-     * v1 === v2  => 0
-     * v1  >  v2  => 1
-     *
-     */
-    function compare(v1, v2) {
-        const sign = (diff) => (diff === 0 ? 0 : diff < 0 ? -1 : 1);
-        const noUndefined = (n) => n !== null && n !== void 0 ? n : Infinity;
-        for (const level of ["major", "minor", "patch", "rc"]) {
-            if (noUndefined(v1[level]) !== noUndefined(v2[level])) {
-                return sign(noUndefined(v1[level]) - noUndefined(v2[level]));
-            }
-        }
-        return 0;
-    }
-    SemVer.compare = compare;
-    /*
-    console.log(compare(parse("3.0.0-rc.3"), parse("3.0.0")) === -1 )
-    console.log(compare(parse("3.0.0-rc.3"), parse("3.0.0-rc.4")) === -1 )
-    console.log(compare(parse("3.0.0-rc.3"), parse("4.0.0")) === -1 )
-    */
-    function bumpType(params) {
-        const versionAhead = typeof params.versionAhead === "string"
-            ? parse(params.versionAhead)
-            : params.versionAhead;
-        const versionBehind = typeof params.versionBehind === "string"
-            ? parse(params.versionBehind)
-            : params.versionBehind;
-        if (compare(versionBehind, versionAhead) === 1) {
-            throw new Error(`Version regression ${stringify(versionBehind)} -> ${stringify(versionAhead)}`);
-        }
-        for (const level of ["major", "minor", "patch", "rc"]) {
-            if (versionBehind[level] !== versionAhead[level]) {
-                return level;
-            }
-        }
-        return "no bump";
-    }
-    SemVer.bumpType = bumpType;
-})(SemVer || (SemVer = {}));
-//# sourceMappingURL=SemVer.js.map
-
-/***/ }),
-
 /***/ 73036:
 /***/ ((__unused_webpack_module, __webpack_exports__, __nccwpck_require__) => {
 
@@ -16190,17 +16104,12 @@ function getBuildContext(params) {
     };
 }
 //# sourceMappingURL=buildContext.js.map
-// EXTERNAL MODULE: ./dist/bin/tools/SemVer.js
-var SemVer = __nccwpck_require__(12171);
 ;// CONCATENATED MODULE: ./dist/bin/main.js
 
 
 
 
 
-
-
-
 assertNoPnpmDlx();
 const program = Z({
     name: "keycloakify",
@@ -16293,36 +16202,10 @@ program
     skip,
     handler: async ({ projectDirPath, keycloakVersion, port, realmJsonFilePath }) => {
         const { command } = await Promise.all(/* import() */[__nccwpck_require__.e(805), __nccwpck_require__.e(525), __nccwpck_require__.e(33), __nccwpck_require__.e(503), __nccwpck_require__.e(682)]).then(__nccwpck_require__.bind(__nccwpck_require__, 6682));
-        validate_keycloak_version: {
-            if (keycloakVersion === undefined) {
-                break validate_keycloak_version;
-            }
-            const isValidVersion = (() => {
-                if (typeof keycloakVersion === "number") {
-                    return false;
-                }
-                try {
-                    SemVer/* SemVer.parse */.h.parse(keycloakVersion);
-                }
-                catch (_a) {
-                    return false;
-                }
-                return;
-            })();
-            if (isValidVersion) {
-                break validate_keycloak_version;
-            }
-            console.log(source_default().red([
-                `Invalid Keycloak version: ${keycloakVersion}`,
-                "It should be a valid semver version example: 26.0.4"
-            ].join(" ")));
-            process.exit(1);
-        }
-        (0,assert/* assert */.h)((0,assert.is)(keycloakVersion));
         await command({
             buildContext: getBuildContext({ projectDirPath }),
             cliCommandOptions: {
-                keycloakVersion,
+                keycloakVersion: keycloakVersion === undefined ? undefined : `${keycloakVersion}`,
                 port,
                 realmJsonFilePath
             }

package/bin/start-keycloak/getSupportedDockerImageTags.d.ts

@@ -5,4 +5,7 @@ export type BuildContextLike = {
 };
 export declare function getSupportedDockerImageTags(params: {
     buildContext: BuildContextLike;
-}): Promise<string[]>;
+}): Promise<{
+    allSupportedTags: string[];
+    latestMajorTags: string[];
+}>;

package/bin/start-keycloak/realmConfig/ParsedRealmJson.d.ts

@@ -30,7 +30,14 @@ export type ParsedRealmJson = {
             "post.logout.redirect.uris"?: string;
         };
         protocol?: string;
-        protocolMappers?: unknown[];
+        protocolMappers?: {
+            id: string;
+            name: string;
+            protocol: string;
+            protocolMapper: string;
+            consentRequired: boolean;
+            config?: Record<string, string>;
+        }[];
     }[];
 };
 export declare function readRealmJsonFile(params: {