keycloakify 10.0.0-rc.7 → 10.0.0-rc.70

package/bin/526.index.js

@@ -0,0 +1,973 @@
+"use strict";
+exports.id = 526;
+exports.ids = [526];
+exports.modules = {
+
+/***/ 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, excludeMajorVersions, 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;
+        }
+        if (excludeMajorVersions.includes(semVersionedTag.version.major)) {
+            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/constants.js
+var constants = __webpack_require__(173);
+// EXTERNAL MODULE: ./dist/bin/tools/SemVer.js
+var SemVer = __webpack_require__(12171);
+// 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, shell: true });
+    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 { buildForKeycloakMajorVersionNumber, buildContext } = 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), { [constants/* buildForKeycloakMajorVersionEnvName */.um]: `${buildForKeycloakMajorVersionNumber}` }),
+        shell: 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
+// EXTERNAL MODULE: ./dist/bin/tools/isInside.js
+var isInside = __webpack_require__(90665);
+// EXTERNAL MODULE: ./dist/bin/tools/fs.existsAsync.js
+var fs_existsAsync = __webpack_require__(43765);
+// EXTERNAL MODULE: ./dist/bin/tools/fs.rm.js
+var fs_rm = __webpack_require__(8699);
+;// 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 { keycloakVersion } = await (async () => {
+        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: 18,
+            excludeMajorVersions: [22],
+            cacheDirPath: buildContext.cacheDirPath
+        });
+        console.log(`→ ${keycloakVersion}`);
+        return { keycloakVersion };
+    })();
+    const keycloakMajorVersionNumber = SemVer/* SemVer.parse */.h.parse(keycloakVersion).major;
+    {
+        const { isAppBuildSuccess } = await appBuild({
+            buildContext
+        });
+        if (!isAppBuildSuccess) {
+            console.log(source_default().red(`App build failed, exiting. Try running 'npm run build' and see what's wrong.`));
+            process.exit(1);
+        }
+        const { isKeycloakifyBuildSuccess } = await keycloakifyBuild({
+            buildForKeycloakMajorVersionNumber: keycloakMajorVersionNumber,
+            buildContext
+        });
+        if (!isKeycloakifyBuildSuccess) {
+            console.log(source_default().red(`Keycloakify build failed, exiting. Try running 'npx keycloakify build' and see what's wrong.`));
+            process.exit(1);
+        }
+    }
+    const jarFilePath = external_fs_.readdirSync(buildContext.keycloakifyBuildDirPath)
+        .filter(fileBasename => fileBasename.endsWith(".jar"))
+        .map(fileBasename => (0,external_path_.join)(buildContext.keycloakifyBuildDirPath, fileBasename))
+        .sort((a, b) => external_fs_.statSync(b).mtimeMs - external_fs_.statSync(a).mtimeMs)[0];
+    (0,assert.assert)(jarFilePath !== undefined);
+    console.log(`Using ${source_default().bold((0,external_path_.basename)(jarFilePath))}`);
+    const realmJsonFilePath = await (async () => {
+        if (cliCommandOptions.realmJsonFilePath !== undefined) {
+            if (cliCommandOptions.realmJsonFilePath === "none") {
+                return undefined;
+            }
+            console.log(source_default().green(`Using realm json file: ${cliCommandOptions.realmJsonFilePath}`));
+            return (0,getAbsoluteAndInOsFormatPath/* getAbsoluteAndInOsFormatPath */.c)({
+                pathIsh: cliCommandOptions.realmJsonFilePath,
+                cwd: process.cwd()
+            });
+        }
+        const internalFilePath = await (async () => {
+            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);
+        })();
+        if (internalFilePath === undefined) {
+            return undefined;
+        }
+        const filePath = (0,external_path_.join)(buildContext.cacheDirPath, (0,external_path_.basename)(internalFilePath));
+        external_fs_.writeFileSync(filePath, Buffer.from(external_fs_.readFileSync(internalFilePath)
+            .toString("utf8")
+            .replace(/keycloakify\-starter/g, buildContext.themeNames[0])), "utf8");
+        return filePath;
+    })();
+    async function extractThemeResourcesFromJar() {
+        await (0,extractArchive/* extractArchive */.N)({
+            archiveFilePath: jarFilePath,
+            onArchiveFile: async ({ relativeFilePathInArchive, writeFile }) => {
+                if ((0,isInside/* isInside */.V)({ dirPath: "theme", filePath: relativeFilePathInArchive })) {
+                    await writeFile({
+                        filePath: (0,external_path_.join)(buildContext.keycloakifyBuildDirPath, relativeFilePathInArchive)
+                    });
+                }
+            }
+        });
+    }
+    {
+        const destDirPath = (0,external_path_.join)(buildContext.keycloakifyBuildDirPath, "theme");
+        if (await (0,fs_existsAsync/* existsAsync */.o)(destDirPath)) {
+            await (0,fs_rm.rm)(destDirPath, { recursive: true });
+        }
+    }
+    await extractThemeResourcesFromJar();
+    const jarFilePath_cacheDir = (0,external_path_.join)(buildContext.cacheDirPath, (0,external_path_.basename)(jarFilePath));
+    external_fs_.copyFileSync(jarFilePath, jarFilePath_cacheDir);
+    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_cacheDir}:/opt/keycloak/providers/keycloak-theme.jar`
+            ],
+            ...(keycloakMajorVersionNumber <= 20
+                ? ["-e", "JAVA_OPTS=-Dkeycloak.profile=preview"]
+                : []),
+            ...[
+                ...buildContext.themeNames,
+                ...(external_fs_.existsSync((0,external_path_.join)(buildContext.keycloakifyBuildDirPath, "theme", constants/* accountV1ThemeName */.y_))
+                    ? [constants/* accountV1ThemeName */.y_]
+                    : [])
+            ]
+                .map(themeName => ({
+                localDirPath: (0,external_path_.join)(buildContext.keycloakifyBuildDirPath, "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,
+            shell: true
+        }
+    ];
+    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([
+                "",
+                `The ftl files from ${source_default().bold(`.${external_path_.sep}${(0,external_path_.relative)(process.cwd(), (0,external_path_.join)(buildContext.keycloakifyBuildDirPath, "theme"))}`)} are mounted in the Keycloak container.`,
+                "",
+                `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({
+                buildForKeycloakMajorVersionNumber: keycloakMajorVersionNumber,
+                buildContext
+            });
+            if (!isKeycloakifyBuildSuccess) {
+                return;
+            }
+            await extractThemeResourcesFromJar();
+            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
+
+/***/ }),
+
+/***/ 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
+
+/***/ }),
+
+/***/ 29121:
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   "N": () => (/* binding */ extractArchive)
+/* harmony export */ });
+/* harmony import */ var fs_promises__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(73292);
+/* harmony import */ var fs_promises__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(fs_promises__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__);
+/* harmony import */ var yauzl__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(78781);
+/* harmony import */ var stream__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(12781);
+/* harmony import */ var stream__WEBPACK_IMPORTED_MODULE_3___default = /*#__PURE__*/__webpack_require__.n(stream__WEBPACK_IMPORTED_MODULE_3__);
+/* harmony import */ var evt_tools_Deferred__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(50689);
+/* harmony import */ var evt_tools_Deferred__WEBPACK_IMPORTED_MODULE_4___default = /*#__PURE__*/__webpack_require__.n(evt_tools_Deferred__WEBPACK_IMPORTED_MODULE_4__);
+/* harmony import */ var path__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(71017);
+/* harmony import */ var path__WEBPACK_IMPORTED_MODULE_5___default = /*#__PURE__*/__webpack_require__.n(path__WEBPACK_IMPORTED_MODULE_5__);
+/* harmony import */ var _fs_existsAsync__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(43765);
+
+
+
+
+
+
+
+async function extractArchive(params) {
+    const { archiveFilePath, onArchiveFile } = params;
+    const zipFile = await new Promise((resolve, reject) => {
+        yauzl__WEBPACK_IMPORTED_MODULE_2__.open(archiveFilePath, { lazyEntries: true }, async (error, zipFile) => {
+            if (error) {
+                reject(error);
+                return;
+            }
+            resolve(zipFile);
+        });
+    });
+    const dDone = new evt_tools_Deferred__WEBPACK_IMPORTED_MODULE_4__.Deferred();
+    zipFile.once("end", () => {
+        zipFile.close();
+        dDone.resolve();
+    });
+    const writeFile = async (entry, params) => {
+        const { filePath, modifiedData } = params;
+        {
+            const dirPath = (0,path__WEBPACK_IMPORTED_MODULE_5__.dirname)(filePath);
+            if (!(await (0,_fs_existsAsync__WEBPACK_IMPORTED_MODULE_6__/* .existsAsync */ .o)(dirPath))) {
+                await fs_promises__WEBPACK_IMPORTED_MODULE_0___default().mkdir(dirPath, { recursive: true });
+            }
+        }
+        if (modifiedData !== undefined) {
+            await fs_promises__WEBPACK_IMPORTED_MODULE_0___default().writeFile(filePath, modifiedData);
+            return;
+        }
+        const readStream = await new Promise(resolve => zipFile.openReadStream(entry, async (error, readStream) => {
+            if (error) {
+                dDone.reject(error);
+                return;
+            }
+            resolve(readStream);
+        }));
+        const dDoneWithFile = new evt_tools_Deferred__WEBPACK_IMPORTED_MODULE_4__.Deferred();
+        stream__WEBPACK_IMPORTED_MODULE_3___default().pipeline(readStream, fs__WEBPACK_IMPORTED_MODULE_1___default().createWriteStream(filePath), error => {
+            if (error) {
+                dDone.reject(error);
+                return;
+            }
+            dDoneWithFile.resolve();
+        });
+        await dDoneWithFile.pr;
+    };
+    const readFile = (entry) => new Promise(resolve => zipFile.openReadStream(entry, async (error, readStream) => {
+        if (error) {
+            dDone.reject(error);
+            return;
+        }
+        const chunks = [];
+        readStream.on("data", chunk => {
+            chunks.push(chunk);
+        });
+        readStream.on("end", () => {
+            resolve(Buffer.concat(chunks));
+        });
+        readStream.on("error", error => {
+            dDone.reject(error);
+        });
+    }));
+    zipFile.on("entry", async (entry) => {
+        handle_file: {
+            // NOTE: Skip directories
+            if (entry.fileName.endsWith("/")) {
+                break handle_file;
+            }
+            let hasEarlyExitBeenCalled = false;
+            await onArchiveFile({
+                relativeFilePathInArchive: entry.fileName.split("/").join(path__WEBPACK_IMPORTED_MODULE_5__.sep),
+                readFile: () => readFile(entry),
+                writeFile: params => writeFile(entry, params),
+                earlyExit: () => {
+                    hasEarlyExitBeenCalled = true;
+                }
+            });
+            if (hasEarlyExitBeenCalled) {
+                zipFile.close();
+                dDone.resolve();
+                return;
+            }
+        }
+        zipFile.readEntry();
+    });
+    zipFile.readEntry();
+    await dDone.pr;
+}
+//# sourceMappingURL=extractArchive.js.map
+
+/***/ }),
+
+/***/ 43765:
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   "o": () => (/* binding */ existsAsync)
+/* harmony export */ });
+/* harmony import */ var fs_promises__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(73292);
+/* harmony import */ var fs_promises__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(fs_promises__WEBPACK_IMPORTED_MODULE_0__);
+
+async function existsAsync(path) {
+    try {
+        await fs_promises__WEBPACK_IMPORTED_MODULE_0__.stat(path);
+        return true;
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return false;
+        throw error;
+    }
+}
+//# sourceMappingURL=fs.existsAsync.js.map
+
+/***/ }),
+
+/***/ 8699:
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   "rm": () => (/* binding */ rm)
+/* harmony export */ });
+/* harmony import */ var fs_promises__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(73292);
+/* harmony import */ var fs_promises__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(fs_promises__WEBPACK_IMPORTED_MODULE_0__);
+/* harmony import */ var path__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(71017);
+/* harmony import */ var path__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(path__WEBPACK_IMPORTED_MODULE_1__);
+/* harmony import */ var _SemVer__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(12171);
+
+
+
+/**
+ * Polyfill of fs.rm(dirPath, { "recursive": true })
+ * For older version of Node
+ */
+async function rm(dirPath, options) {
+    if (_SemVer__WEBPACK_IMPORTED_MODULE_2__/* .SemVer.compare */ .h.compare(_SemVer__WEBPACK_IMPORTED_MODULE_2__/* .SemVer.parse */ .h.parse(process.version), _SemVer__WEBPACK_IMPORTED_MODULE_2__/* .SemVer.parse */ .h.parse("14.14.0")) > 0) {
+        return fs_promises__WEBPACK_IMPORTED_MODULE_0__.rm(dirPath, options);
+    }
+    const { force = true } = options;
+    if (force && !(await checkDirExists(dirPath))) {
+        return;
+    }
+    const removeDir_rec = async (dirPath) => Promise.all((await fs_promises__WEBPACK_IMPORTED_MODULE_0__.readdir(dirPath)).map(async (basename) => {
+        const fileOrDirpath = (0,path__WEBPACK_IMPORTED_MODULE_1__.join)(dirPath, basename);
+        if ((await fs_promises__WEBPACK_IMPORTED_MODULE_0__.lstat(fileOrDirpath)).isDirectory()) {
+            await removeDir_rec(fileOrDirpath);
+        }
+        else {
+            await fs_promises__WEBPACK_IMPORTED_MODULE_0__.unlink(fileOrDirpath);
+        }
+    }));
+    await removeDir_rec(dirPath);
+}
+async function checkDirExists(dirPath) {
+    try {
+        await fs_promises__WEBPACK_IMPORTED_MODULE_0__.access(dirPath, fs_promises__WEBPACK_IMPORTED_MODULE_0__.constants.F_OK);
+        return true;
+    }
+    catch (_a) {
+        return false;
+    }
+}
+//# sourceMappingURL=fs.rm.js.map
+
+/***/ }),
+
+/***/ 90665:
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   "V": () => (/* binding */ isInside)
+/* 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__);
+
+function isInside(params) {
+    const { dirPath, filePath } = params;
+    return !(0,path__WEBPACK_IMPORTED_MODULE_0__.relative)(dirPath, filePath).startsWith("..");
+}
+//# sourceMappingURL=isInside.js.map
+
+/***/ })
+
+};
+;