keycloakify 10.0.0-rc.4 → 10.0.0-rc.41

package/bin/526.index.js

@@ -0,0 +1,757 @@
+"use strict";
+exports.id = 526;
+exports.ids = [526];
+exports.modules = {
+
+/***/ 2323:
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   "m": () => (/* binding */ getJarFileBasename)
+/* harmony export */ });
+function getJarFileBasename(params) {
+    const { keycloakVersionRange } = params;
+    const jarFileBasename = `keycloak-theme-for-kc-${keycloakVersionRange}.jar`;
+    return { jarFileBasename };
+}
+//# sourceMappingURL=getJarFileBasename.js.map
+
+/***/ }),
+
+/***/ 26914:
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   "As": () => (/* binding */ readMetaInfKeycloakThemes),
+/* harmony export */   "JJ": () => (/* binding */ writeMetaInfKeycloakThemes),
+/* harmony export */   "KQ": () => (/* binding */ getMetaInfKeycloakThemesJsonFilePath)
+/* harmony export */ });
+/* harmony import */ var path__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(71017);
+/* harmony import */ var path__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(path__WEBPACK_IMPORTED_MODULE_0__);
+/* harmony import */ var fs__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(57147);
+/* harmony import */ var fs__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(fs__WEBPACK_IMPORTED_MODULE_1__);
+
+
+function getMetaInfKeycloakThemesJsonFilePath(params) {
+    const { keycloakifyBuildDirPath } = params;
+    return (0,path__WEBPACK_IMPORTED_MODULE_0__.join)(keycloakifyBuildDirPath === "." ? "" : keycloakifyBuildDirPath, "src", "main", "resources", "META-INF", "keycloak-themes.json");
+}
+function readMetaInfKeycloakThemes(params) {
+    const { keycloakifyBuildDirPath } = params;
+    return JSON.parse(fs__WEBPACK_IMPORTED_MODULE_1__.readFileSync(getMetaInfKeycloakThemesJsonFilePath({
+        keycloakifyBuildDirPath
+    }))
+        .toString("utf8"));
+}
+function writeMetaInfKeycloakThemes(params) {
+    const { keycloakifyBuildDirPath, metaInfKeycloakThemes } = params;
+    const metaInfKeycloakThemesJsonPath = getMetaInfKeycloakThemesJsonFilePath({
+        keycloakifyBuildDirPath
+    });
+    {
+        const dirPath = (0,path__WEBPACK_IMPORTED_MODULE_0__.dirname)(metaInfKeycloakThemesJsonPath);
+        if (!fs__WEBPACK_IMPORTED_MODULE_1__.existsSync(dirPath)) {
+            fs__WEBPACK_IMPORTED_MODULE_1__.mkdirSync(dirPath, { recursive: true });
+        }
+    }
+    fs__WEBPACK_IMPORTED_MODULE_1__.writeFileSync(metaInfKeycloakThemesJsonPath, Buffer.from(JSON.stringify(metaInfKeycloakThemes, null, 2), "utf8"));
+}
+//# sourceMappingURL=metaInfKeycloakThemes.js.map
+
+/***/ }),
+
+/***/ 95781:
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+
+// EXPORTS
+__webpack_require__.d(__webpack_exports__, {
+  "s": () => (/* binding */ promptKeycloakVersion)
+});
+
+;// CONCATENATED MODULE: ./dist/bin/tools/octokit-addons/listTags.js
+var __await = (undefined && undefined.__await) || function (v) { return this instanceof __await ? (this.v = v, this) : new __await(v); }
+var __asyncGenerator = (undefined && undefined.__asyncGenerator) || function (thisArg, _arguments, generator) {
+    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+    var g = generator.apply(thisArg, _arguments || []), i, q = [];
+    return i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i;
+    function verb(n) { if (g[n]) i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; }
+    function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }
+    function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }
+    function fulfill(value) { resume("next", value); }
+    function reject(value) { resume("throw", value); }
+    function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }
+};
+const per_page = 99;
+function listTagsFactory(params) {
+    const { octokit } = params;
+    const octokit_repo_listTags = async (params) => {
+        return octokit.repos.listTags(params);
+    };
+    function listTags(params) {
+        return __asyncGenerator(this, arguments, function* listTags_1() {
+            const { owner, repo } = params;
+            let page = 1;
+            while (true) {
+                const resp = yield __await(octokit_repo_listTags({
+                    owner,
+                    repo,
+                    per_page,
+                    page: page++
+                }));
+                for (const branch of resp.data.map(({ name }) => name)) {
+                    yield yield __await(branch);
+                }
+                if (resp.data.length < 99) {
+                    break;
+                }
+            }
+        });
+    }
+    /** Returns the same "latest" tag as deno.land/x, not actually the latest though */
+    async function getLatestTag(params) {
+        const { owner, repo } = params;
+        const itRes = await listTags({ owner, repo }).next();
+        if (itRes.done) {
+            return undefined;
+        }
+        return itRes.value;
+    }
+    return { listTags, getLatestTag };
+}
+//# sourceMappingURL=listTags.js.map
+// EXTERNAL MODULE: ./dist/bin/tools/SemVer.js
+var SemVer = __webpack_require__(12171);
+;// CONCATENATED MODULE: ./dist/bin/tools/octokit-addons/getLatestsSemVersionedTag.js
+var __asyncValues = (undefined && undefined.__asyncValues) || function (o) {
+    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+    var m = o[Symbol.asyncIterator], i;
+    return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i);
+    function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }
+    function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }
+};
+
+
+function getLatestsSemVersionedTagFactory(params) {
+    const { octokit } = params;
+    async function getLatestsSemVersionedTag(params) {
+        var _a, e_1, _b, _c;
+        const { owner, repo, count } = params;
+        const semVersionedTags = [];
+        const { listTags } = listTagsFactory({ octokit });
+        try {
+            for (var _d = true, _e = __asyncValues(listTags({ owner, repo })), _f; _f = await _e.next(), _a = _f.done, !_a;) {
+                _c = _f.value;
+                _d = false;
+                try {
+                    const tag = _c;
+                    let version;
+                    try {
+                        version = SemVer/* SemVer.parse */.h.parse(tag.replace(/^[vV]?/, ""));
+                    }
+                    catch (_g) {
+                        continue;
+                    }
+                    if (version.rc !== undefined) {
+                        continue;
+                    }
+                    semVersionedTags.push({ tag, version });
+                }
+                finally {
+                    _d = true;
+                }
+            }
+        }
+        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+        finally {
+            try {
+                if (!_d && !_a && (_b = _e.return)) await _b.call(_e);
+            }
+            finally { if (e_1) throw e_1.error; }
+        }
+        return semVersionedTags
+            .sort(({ version: vX }, { version: vY }) => SemVer/* SemVer.compare */.h.compare(vY, vX))
+            .slice(0, count);
+    }
+    return { getLatestsSemVersionedTag };
+}
+//# sourceMappingURL=getLatestsSemVersionedTag.js.map
+// EXTERNAL MODULE: ./node_modules/@octokit/rest/dist-node/index.js
+var dist_node = __webpack_require__(55375);
+// EXTERNAL MODULE: ./node_modules/cli-select/dist/index.js
+var dist = __webpack_require__(99398);
+var dist_default = /*#__PURE__*/__webpack_require__.n(dist);
+// EXTERNAL MODULE: external "path"
+var external_path_ = __webpack_require__(71017);
+// EXTERNAL MODULE: external "fs"
+var external_fs_ = __webpack_require__(57147);
+// EXTERNAL MODULE: ./node_modules/tsafe/id.js
+var id = __webpack_require__(43047);
+;// CONCATENATED MODULE: ./dist/bin/shared/promptKeycloakVersion.js
+
+
+
+
+
+
+
+async function promptKeycloakVersion(params) {
+    const { startingFromMajor, cacheDirPath } = params;
+    const { getLatestsSemVersionedTag } = (() => {
+        const { octokit } = (() => {
+            const githubToken = process.env.GITHUB_TOKEN;
+            const octokit = new dist_node.Octokit(githubToken === undefined ? undefined : { auth: githubToken });
+            return { octokit };
+        })();
+        const { getLatestsSemVersionedTag } = getLatestsSemVersionedTagFactory({
+            octokit
+        });
+        return { getLatestsSemVersionedTag };
+    })();
+    const semVersionedTagByMajor = new Map();
+    const semVersionedTags = await (async () => {
+        const cacheFilePath = (0,external_path_.join)(cacheDirPath, "keycloak-versions.json");
+        use_cache: {
+            if (!external_fs_.existsSync(cacheFilePath)) {
+                break use_cache;
+            }
+            const cache = JSON.parse(external_fs_.readFileSync(cacheFilePath).toString("utf8"));
+            if (Date.now() - cache.time > 3600000) {
+                external_fs_.unlinkSync(cacheFilePath);
+                break use_cache;
+            }
+            return cache.semVersionedTags;
+        }
+        const semVersionedTags = await getLatestsSemVersionedTag({
+            count: 50,
+            owner: "keycloak",
+            repo: "keycloak"
+        });
+        {
+            const dirPath = (0,external_path_.dirname)(cacheFilePath);
+            if (!external_fs_.existsSync(dirPath)) {
+                external_fs_.mkdirSync(dirPath, { recursive: true });
+            }
+        }
+        external_fs_.writeFileSync(cacheFilePath, JSON.stringify((0,id.id)({
+            time: Date.now(),
+            semVersionedTags
+        }), null, 2));
+        return semVersionedTags;
+    })();
+    semVersionedTags.forEach(semVersionedTag => {
+        if (startingFromMajor !== undefined &&
+            semVersionedTag.version.major < startingFromMajor) {
+            return;
+        }
+        const currentSemVersionedTag = semVersionedTagByMajor.get(semVersionedTag.version.major);
+        if (currentSemVersionedTag !== undefined &&
+            SemVer/* SemVer.compare */.h.compare(semVersionedTag.version, currentSemVersionedTag.version) === -1) {
+            return;
+        }
+        semVersionedTagByMajor.set(semVersionedTag.version.major, semVersionedTag);
+    });
+    const lastMajorVersions = Array.from(semVersionedTagByMajor.values()).map(({ tag }) => tag);
+    const { value } = await dist_default()({
+        values: lastMajorVersions
+    }).catch(() => {
+        process.exit(-1);
+    });
+    const keycloakVersion = value.split(" ")[0];
+    return { keycloakVersion };
+}
+//# sourceMappingURL=promptKeycloakVersion.js.map
+
+/***/ }),
+
+/***/ 80526:
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+// ESM COMPAT FLAG
+__webpack_require__.r(__webpack_exports__);
+
+// EXPORTS
+__webpack_require__.d(__webpack_exports__, {
+  "command": () => (/* reexport */ command)
+});
+
+// EXTERNAL MODULE: ./dist/bin/shared/buildContext.js + 1 modules
+var shared_buildContext = __webpack_require__(87751);
+// EXTERNAL MODULE: ./node_modules/tsafe/exclude.js
+var exclude = __webpack_require__(41370);
+// EXTERNAL MODULE: ./dist/bin/shared/promptKeycloakVersion.js + 2 modules
+var promptKeycloakVersion = __webpack_require__(95781);
+// EXTERNAL MODULE: ./dist/bin/shared/metaInfKeycloakThemes.js
+var shared_metaInfKeycloakThemes = __webpack_require__(26914);
+// EXTERNAL MODULE: ./dist/bin/shared/constants.js
+var constants = __webpack_require__(173);
+// EXTERNAL MODULE: ./dist/bin/tools/SemVer.js
+var SemVer = __webpack_require__(12171);
+// EXTERNAL MODULE: ./dist/bin/shared/getJarFileBasename.js
+var getJarFileBasename = __webpack_require__(2323);
+// EXTERNAL MODULE: ./node_modules/tsafe/assert.js
+var assert = __webpack_require__(88078);
+// EXTERNAL MODULE: external "fs"
+var external_fs_ = __webpack_require__(57147);
+// EXTERNAL MODULE: external "path"
+var external_path_ = __webpack_require__(71017);
+// EXTERNAL MODULE: external "child_process"
+var external_child_process_ = __webpack_require__(32081);
+// EXTERNAL MODULE: ./node_modules/chalk/source/index.js
+var source = __webpack_require__(78818);
+var source_default = /*#__PURE__*/__webpack_require__.n(source);
+// EXTERNAL MODULE: ./node_modules/chokidar/index.js
+var chokidar = __webpack_require__(42677);
+// EXTERNAL MODULE: ./node_modules/powerhooks/tools/waitForDebounce.js
+var tools_waitForDebounce = __webpack_require__(18721);
+// EXTERNAL MODULE: ./dist/bin/tools/getThisCodebaseRootDirPath.js
+var getThisCodebaseRootDirPath = __webpack_require__(58822);
+// EXTERNAL MODULE: ./dist/bin/tools/getAbsoluteAndInOsFormatPath.js
+var getAbsoluteAndInOsFormatPath = __webpack_require__(86644);
+// EXTERNAL MODULE: ./node_modules/cli-select/dist/index.js
+var dist = __webpack_require__(99398);
+var dist_default = /*#__PURE__*/__webpack_require__.n(dist);
+// EXTERNAL MODULE: ./node_modules/run-exclusive/lib/runExclusive.js
+var runExclusive = __webpack_require__(81708);
+// EXTERNAL MODULE: ./dist/bin/tools/extractArchive.js
+var extractArchive = __webpack_require__(29121);
+// EXTERNAL MODULE: ./node_modules/evt/tools/Deferred.js
+var Deferred = __webpack_require__(50689);
+// EXTERNAL MODULE: ./node_modules/tsafe/is.js
+var is = __webpack_require__(94655);
+;// CONCATENATED MODULE: ./dist/bin/start-keycloak/appBuild.js
+
+
+
+
+
+
+(0,assert.assert)();
+async function appBuild(params) {
+    const { buildContext } = params;
+    const { bundler } = buildContext;
+    const { command, args, cwd } = (() => {
+        var _a;
+        switch (bundler) {
+            case "vite":
+                return {
+                    command: "npx",
+                    args: ["vite", "build"],
+                    cwd: buildContext.projectDirPath
+                };
+            case "webpack": {
+                for (const dirPath of [
+                    buildContext.projectDirPath,
+                    buildContext.npmWorkspaceRootDirPath
+                ]) {
+                    try {
+                        const parsedPackageJson = JSON.parse(external_fs_.readFileSync((0,external_path_.join)(dirPath, "package.json"))
+                            .toString("utf8"));
+                        const [scriptName] = (_a = Object.entries(parsedPackageJson.scripts).find(([, scriptValue]) => {
+                            (0,assert.assert)((0,is.is)(scriptValue));
+                            if (scriptValue.includes("webpack") &&
+                                scriptValue.includes("--mode production")) {
+                                return true;
+                            }
+                            if (scriptValue.includes("react-scripts") &&
+                                scriptValue.includes("build")) {
+                                return true;
+                            }
+                            if (scriptValue.includes("react-app-rewired") &&
+                                scriptValue.includes("build")) {
+                                return true;
+                            }
+                            if (scriptValue.includes("craco") &&
+                                scriptValue.includes("build")) {
+                                return true;
+                            }
+                            if (scriptValue.includes("ng") &&
+                                scriptValue.includes("build")) {
+                                return true;
+                            }
+                            return false;
+                        })) !== null && _a !== void 0 ? _a : [];
+                        if (scriptName === undefined) {
+                            continue;
+                        }
+                        return {
+                            command: "npm",
+                            args: ["run", scriptName],
+                            cwd: dirPath
+                        };
+                    }
+                    catch (_b) {
+                        continue;
+                    }
+                }
+                throw new Error("Keycloakify was unable to determine which script is responsible for building the app.");
+            }
+        }
+    })();
+    const dResult = new Deferred.Deferred();
+    const child = external_child_process_.spawn(command, args, { cwd });
+    child.stdout.on("data", data => {
+        if (data.toString("utf8").includes("gzip:")) {
+            return;
+        }
+        process.stdout.write(data);
+    });
+    child.stderr.on("data", data => process.stderr.write(data));
+    child.on("exit", code => dResult.resolve({ isSuccess: code === 0 }));
+    const { isSuccess } = await dResult.pr;
+    return { isAppBuildSuccess: isSuccess };
+}
+//# sourceMappingURL=appBuild.js.map
+;// CONCATENATED MODULE: ./dist/bin/start-keycloak/keycloakifyBuild.js
+
+
+
+
+(0,assert.assert)();
+async function keycloakifyBuild(params) {
+    const { buildContext, doSkipBuildJars } = params;
+    const dResult = new Deferred.Deferred();
+    const child = external_child_process_.spawn("npx", ["keycloakify", "build"], {
+        cwd: buildContext.projectDirPath,
+        env: Object.assign(Object.assign({}, process.env), (doSkipBuildJars ? { [constants/* skipBuildJarsEnvName */.uo]: "true" } : {}))
+    });
+    child.stdout.on("data", data => process.stdout.write(data));
+    child.stderr.on("data", data => process.stderr.write(data));
+    child.on("exit", code => dResult.resolve({ isSuccess: code === 0 }));
+    const { isSuccess } = await dResult.pr;
+    return { isKeycloakifyBuildSuccess: isSuccess };
+}
+//# sourceMappingURL=keycloakifyBuild.js.map
+;// CONCATENATED MODULE: ./dist/bin/start-keycloak/start-keycloak.js
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+async function command(params) {
+    exit_if_docker_not_installed: {
+        let commandOutput = undefined;
+        try {
+            commandOutput = external_child_process_.execSync("docker --version", {
+                stdio: ["ignore", "pipe", "ignore"]
+            });
+        }
+        catch (_a) { }
+        if (commandOutput === null || commandOutput === void 0 ? void 0 : commandOutput.toString("utf8").includes("Docker")) {
+            break exit_if_docker_not_installed;
+        }
+        console.log([
+            `${source_default().red("Docker required.")}`,
+            `Install it with Docker Desktop: ${source_default().bold.underline("https://www.docker.com/products/docker-desktop/")}`,
+            `(or any other way)`
+        ].join(" "));
+        process.exit(1);
+    }
+    exit_if_docker_not_running: {
+        let isDockerRunning;
+        try {
+            external_child_process_.execSync("docker info", { stdio: "ignore" });
+            isDockerRunning = true;
+        }
+        catch (_b) {
+            isDockerRunning = false;
+        }
+        if (isDockerRunning) {
+            break exit_if_docker_not_running;
+        }
+        console.log([
+            `${source_default().red("Docker daemon is not running.")}`,
+            `Please start Docker Desktop and try again.`
+        ].join(" "));
+        process.exit(1);
+    }
+    const { cliCommandOptions } = params;
+    const buildContext = (0,shared_buildContext/* getBuildContext */.s)({ cliCommandOptions });
+    {
+        const { isAppBuildSuccess } = await appBuild({
+            buildContext
+        });
+        if (!isAppBuildSuccess) {
+            console.log(source_default().red(`App build failed, exiting. Try running 'yarn build-keycloak-theme' and see what's wrong.`));
+            process.exit(1);
+        }
+        const { isKeycloakifyBuildSuccess } = await keycloakifyBuild({
+            doSkipBuildJars: false,
+            buildContext
+        });
+        if (!isKeycloakifyBuildSuccess) {
+            console.log(source_default().red(`Keycloakify build failed, exiting. Try running 'yarn build-keycloak-theme' and see what's wrong.`));
+            process.exit(1);
+        }
+    }
+    const metaInfKeycloakThemes = (0,shared_metaInfKeycloakThemes/* readMetaInfKeycloakThemes */.As)({
+        keycloakifyBuildDirPath: buildContext.keycloakifyBuildDirPath
+    });
+    const doesImplementAccountTheme = metaInfKeycloakThemes.themes.some(({ name }) => name === constants/* accountV1ThemeName */.y_);
+    const { keycloakVersion, keycloakMajorNumber: keycloakMajorVersionNumber } = await (async function getKeycloakMajor() {
+        if (cliCommandOptions.keycloakVersion !== undefined) {
+            return {
+                keycloakVersion: cliCommandOptions.keycloakVersion,
+                keycloakMajorNumber: SemVer/* SemVer.parse */.h.parse(cliCommandOptions.keycloakVersion)
+                    .major
+            };
+        }
+        console.log(source_default().cyan("On which version of Keycloak do you want to test your theme?"));
+        const { keycloakVersion } = await (0,promptKeycloakVersion/* promptKeycloakVersion */.s)({
+            startingFromMajor: 17,
+            cacheDirPath: buildContext.cacheDirPath
+        });
+        console.log(`→ ${keycloakVersion}`);
+        const keycloakMajorNumber = SemVer/* SemVer.parse */.h.parse(keycloakVersion).major;
+        if (doesImplementAccountTheme && keycloakMajorNumber === 22) {
+            console.log([
+                "Unfortunately, Keycloakify themes that implements an account theme do not work on Keycloak 22",
+                "Please select any other Keycloak version"
+            ].join(" "));
+            return getKeycloakMajor();
+        }
+        return { keycloakVersion, keycloakMajorNumber };
+    })();
+    const keycloakVersionRange = (() => {
+        if (doesImplementAccountTheme) {
+            const keycloakVersionRange = (() => {
+                if (keycloakMajorVersionNumber <= 21) {
+                    return "21-and-below";
+                }
+                (0,assert.assert)(keycloakMajorVersionNumber !== 22);
+                if (keycloakMajorVersionNumber === 23) {
+                    return "23";
+                }
+                return "24-and-above";
+            })();
+            (0,assert.assert)();
+            return keycloakVersionRange;
+        }
+        else {
+            const keycloakVersionRange = (() => {
+                if (keycloakMajorVersionNumber <= 21) {
+                    return "21-and-below";
+                }
+                return "22-and-above";
+            })();
+            (0,assert.assert)();
+            return keycloakVersionRange;
+        }
+    })();
+    const { jarFileBasename } = (0,getJarFileBasename/* getJarFileBasename */.m)({ keycloakVersionRange });
+    console.log(`Using Keycloak ${source_default().bold(jarFileBasename)}`);
+    const realmJsonFilePath = await (async () => {
+        if (cliCommandOptions.realmJsonFilePath !== undefined) {
+            console.log(source_default().green(`Using realm json file: ${cliCommandOptions.realmJsonFilePath}`));
+            return (0,getAbsoluteAndInOsFormatPath/* getAbsoluteAndInOsFormatPath */.c)({
+                pathIsh: cliCommandOptions.realmJsonFilePath,
+                cwd: process.cwd()
+            });
+        }
+        const dirPath = (0,external_path_.join)((0,getThisCodebaseRootDirPath/* getThisCodebaseRootDirPath */.e)(), "src", "bin", "start-keycloak");
+        const filePath = (0,external_path_.join)(dirPath, `myrealm-realm-${keycloakMajorVersionNumber}.json`);
+        if (external_fs_.existsSync(filePath)) {
+            return filePath;
+        }
+        console.log(`${source_default().yellow(`Keycloakify do not have a realm configuration for Keycloak ${keycloakMajorVersionNumber} yet.`)}`);
+        console.log(source_default().cyan("Select what configuration to use:"));
+        const { value } = await dist_default()({
+            values: [
+                ...external_fs_.readdirSync(dirPath)
+                    .filter(fileBasename => fileBasename.endsWith(".json")),
+                "none"
+            ]
+        }).catch(() => {
+            process.exit(-1);
+        });
+        if (value === "none") {
+            return undefined;
+        }
+        return (0,external_path_.join)(dirPath, value);
+    })();
+    const jarFilePath = (0,external_path_.join)(buildContext.keycloakifyBuildDirPath, jarFileBasename);
+    const { doUseBuiltInAccountV1Theme } = await (async () => {
+        let doUseBuiltInAccountV1Theme = false;
+        await (0,extractArchive/* extractArchive */.N)({
+            archiveFilePath: jarFilePath,
+            onArchiveFile: async ({ relativeFilePathInArchive, readFile, earlyExit }) => {
+                for (const themeName of buildContext.themeNames) {
+                    if (relativeFilePathInArchive ===
+                        (0,external_path_.join)("theme", themeName, "account", "theme.properties")) {
+                        if ((await readFile())
+                            .toString("utf8")
+                            .includes("parent=keycloak")) {
+                            doUseBuiltInAccountV1Theme = true;
+                        }
+                        earlyExit();
+                    }
+                }
+            }
+        });
+        return { doUseBuiltInAccountV1Theme };
+    })();
+    const accountThemePropertyPatch = !doUseBuiltInAccountV1Theme
+        ? undefined
+        : () => {
+            for (const themeName of buildContext.themeNames) {
+                const filePath = (0,external_path_.join)(buildContext.keycloakifyBuildDirPath, "src", "main", "resources", "theme", themeName, "account", "theme.properties");
+                const sourceCode = external_fs_.readFileSync(filePath);
+                const modifiedSourceCode = Buffer.from(sourceCode
+                    .toString("utf8")
+                    .replace(`parent=${constants/* accountV1ThemeName */.y_}`, "parent=keycloak"), "utf8");
+                (0,assert.assert)(Buffer.compare(modifiedSourceCode, sourceCode) !== 0);
+                external_fs_.writeFileSync(filePath, modifiedSourceCode);
+            }
+        };
+    accountThemePropertyPatch === null || accountThemePropertyPatch === void 0 ? void 0 : accountThemePropertyPatch();
+    try {
+        external_child_process_.execSync(`docker rm --force ${constants/* containerName */.h6}`, {
+            stdio: "ignore"
+        });
+    }
+    catch (_c) { }
+    const spawnArgs = [
+        "docker",
+        [
+            "run",
+            ...["-p", `${cliCommandOptions.port}:8080`],
+            ...["--name", constants/* containerName */.h6],
+            ...["-e", "KEYCLOAK_ADMIN=admin"],
+            ...["-e", "KEYCLOAK_ADMIN_PASSWORD=admin"],
+            ...(realmJsonFilePath === undefined
+                ? []
+                : [
+                    "-v",
+                    `${realmJsonFilePath}:/opt/keycloak/data/import/myrealm-realm.json`
+                ]),
+            ...["-v", `${jarFilePath}:/opt/keycloak/providers/keycloak-theme.jar`],
+            ...(keycloakMajorVersionNumber <= 20
+                ? ["-e", "JAVA_OPTS=-Dkeycloak.profile=preview"]
+                : []),
+            ...[
+                ...buildContext.themeNames,
+                ...(doUseBuiltInAccountV1Theme ? [] : [constants/* accountV1ThemeName */.y_])
+            ]
+                .map(themeName => ({
+                localDirPath: (0,external_path_.join)(buildContext.keycloakifyBuildDirPath, "src", "main", "resources", "theme", themeName),
+                containerDirPath: `/opt/keycloak/themes/${themeName}`
+            }))
+                .map(({ localDirPath, containerDirPath }) => [
+                "-v",
+                `${localDirPath}:${containerDirPath}:rw`
+            ])
+                .flat(),
+            ...buildContext.environmentVariables
+                .map(({ name }) => ({ name, envValue: process.env[name] }))
+                .map(({ name, envValue }) => envValue === undefined ? undefined : { name, envValue })
+                .filter((0,exclude.exclude)(undefined))
+                .map(({ name, envValue }) => [
+                "--env",
+                `${name}='${envValue.replace(/'/g, "'\\''")}'`
+            ])
+                .flat(),
+            `quay.io/keycloak/keycloak:${keycloakVersion}`,
+            "start-dev",
+            ...(21 <= keycloakMajorVersionNumber && keycloakMajorVersionNumber < 24
+                ? ["--features=declarative-user-profile"]
+                : []),
+            ...(realmJsonFilePath === undefined ? [] : ["--import-realm"])
+        ],
+        {
+            cwd: buildContext.keycloakifyBuildDirPath
+        }
+    ];
+    const child = external_child_process_.spawn(...spawnArgs);
+    child.stdout.on("data", data => process.stdout.write(data));
+    child.stderr.on("data", data => process.stderr.write(data));
+    child.on("exit", process.exit);
+    const srcDirPath = (0,external_path_.join)(buildContext.projectDirPath, "src");
+    {
+        const handler = async (data) => {
+            if (!data.toString("utf8").includes("Listening on: http://0.0.0.0:8080")) {
+                return;
+            }
+            child.stdout.off("data", handler);
+            await new Promise(resolve => setTimeout(resolve, 1000));
+            console.log([
+                "",
+                `Keycloak Admin console: ${source_default().cyan.bold(`http://localhost:${cliCommandOptions.port}`)}`,
+                `- user:     ${source_default().cyan.bold("admin")}`,
+                `- password: ${source_default().cyan.bold("admin")}`,
+                "",
+                "",
+                `${source_default().green("Your theme is accessible at:")}`,
+                `${source_default().green("➜")} ${source_default().cyan.bold(`https://my-theme.keycloakify.dev${cliCommandOptions.port === 8080 ? "" : `?port=${cliCommandOptions.port}`}`)}`,
+                "",
+                "You can login with the following credentials:",
+                `- username: ${source_default().cyan.bold("testuser")}`,
+                `- password: ${source_default().cyan.bold("password123")}`,
+                "",
+                `Watching for changes in ${source_default().bold(`.${external_path_.sep}${(0,external_path_.relative)(process.cwd(), buildContext.projectDirPath)}`)}`
+            ].join("\n"));
+        };
+        child.stdout.on("data", handler);
+    }
+    {
+        const runFullBuild = runExclusive.build(async () => {
+            console.log(source_default().cyan("Detected changes in the theme. Rebuilding ..."));
+            const { isAppBuildSuccess } = await appBuild({
+                buildContext
+            });
+            if (!isAppBuildSuccess) {
+                return;
+            }
+            const { isKeycloakifyBuildSuccess } = await keycloakifyBuild({
+                doSkipBuildJars: true,
+                buildContext
+            });
+            if (!isKeycloakifyBuildSuccess) {
+                return;
+            }
+            accountThemePropertyPatch === null || accountThemePropertyPatch === void 0 ? void 0 : accountThemePropertyPatch();
+            console.log(source_default().green("Theme rebuilt and updated in Keycloak."));
+        });
+        const { waitForDebounce } = (0,tools_waitForDebounce/* waitForDebounceFactory */.z)({ delay: 400 });
+        chokidar.watch([
+            srcDirPath,
+            buildContext.publicDirPath,
+            (0,external_path_.join)(buildContext.projectDirPath, "package.json"),
+            (0,external_path_.join)(buildContext.projectDirPath, "vite.config.ts"),
+            (0,external_path_.join)(buildContext.projectDirPath, "vite.config.js"),
+            (0,external_path_.join)(buildContext.projectDirPath, "index.html"),
+            (0,external_path_.join)((0,getThisCodebaseRootDirPath/* getThisCodebaseRootDirPath */.e)(), "src")
+        ], {
+            ignoreInitial: true
+        })
+            .on("all", async (...[, filePath]) => {
+            console.log(`Detected changes in ${filePath}`);
+            await waitForDebounce();
+            runFullBuild();
+        });
+    }
+}
+//# sourceMappingURL=start-keycloak.js.map
+;// CONCATENATED MODULE: ./dist/bin/start-keycloak/index.js
+
+//# sourceMappingURL=index.js.map
+
+/***/ })
+
+};
+;