keycloakify 10.0.0-rc.99 → 10.0.1

package/bin/526.index.js

@@ -3,13 +3,13 @@ exports.id = 526;
 exports.ids = [526];
 exports.modules = {
 
-/***/ 95781:
+/***/ 97189:
 /***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
 
 
 // EXPORTS
 __webpack_require__.d(__webpack_exports__, {
-  "s": () => (/* binding */ promptKeycloakVersion)
+  "_": () => (/* binding */ getLatestsSemVersionedTag)
 });
 
 ;// CONCATENATED MODULE: ./dist/bin/tools/octokit-addons/listTags.js
@@ -79,7 +79,7 @@ function getLatestsSemVersionedTagFactory(params) {
     const { octokit } = params;
     async function getLatestsSemVersionedTag(params) {
         var _a, e_1, _b, _c;
-        const { owner, repo, count } = params;
+        const { owner, repo, count, doIgnoreReleaseCandidates } = params;
         const semVersionedTags = [];
         const { listTags } = listTagsFactory({ octokit });
         try {
@@ -95,7 +95,7 @@ function getLatestsSemVersionedTagFactory(params) {
                     catch (_g) {
                         continue;
                     }
-                    if (version.rc !== undefined) {
+                    if (doIgnoreReleaseCandidates && version.rc !== undefined) {
                         continue;
                     }
                     semVersionedTags.push({ tag, version });
@@ -121,16 +121,33 @@ function getLatestsSemVersionedTagFactory(params) {
 //# 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/zod/lib/index.mjs
+var lib = __webpack_require__(52300);
+// EXTERNAL MODULE: ./node_modules/tsafe/assert.js
+var assert = __webpack_require__(88078);
 // EXTERNAL MODULE: ./node_modules/tsafe/id.js
 var id = __webpack_require__(43047);
-;// CONCATENATED MODULE: ./dist/bin/shared/promptKeycloakVersion.js
+// EXTERNAL MODULE: ./node_modules/evt/tools/inDepth/same.js
+var same = __webpack_require__(33805);
+// EXTERNAL MODULE: ./node_modules/make-fetch-happen/lib/index.js
+var make_fetch_happen_lib = __webpack_require__(9525);
+var lib_default = /*#__PURE__*/__webpack_require__.n(make_fetch_happen_lib);
+;// CONCATENATED MODULE: ./dist/bin/shared/getLatestsSemVersionedTag.js
+var __rest = (undefined && undefined.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
 
 
 
@@ -138,50 +155,152 @@ var id = __webpack_require__(43047);
 
 
 
-async function promptKeycloakVersion(params) {
-    const { startingFromMajor, excludeMajorVersions, cacheDirPath } = params;
-    const { getLatestsSemVersionedTag } = (() => {
-        const { octokit } = (() => {
+
+
+let getLatestsSemVersionedTag_stateless = undefined;
+const CACHE_VERSION = 1;
+(0,assert.assert)();
+async function getLatestsSemVersionedTag(_a) {
+    var { buildContext } = _a, params = __rest(_a, ["buildContext"]);
+    const cacheFilePath = (0,external_path_.join)(buildContext.cacheDirPath, "latest-sem-versioned-tags.json");
+    const cacheLookupResult = (() => {
+        const getResult_currentCache = (currentCacheEntries) => ({
+            hasCachedResult: false,
+            currentCache: {
+                version: CACHE_VERSION,
+                entries: currentCacheEntries
+            }
+        });
+        if (!external_fs_.existsSync(cacheFilePath)) {
+            return getResult_currentCache([]);
+        }
+        let cache_json;
+        try {
+            cache_json = external_fs_.readFileSync(cacheFilePath).toString("utf8");
+        }
+        catch (_a) {
+            return getResult_currentCache([]);
+        }
+        let cache_json_parsed;
+        try {
+            cache_json_parsed = JSON.parse(cache_json);
+        }
+        catch (_b) {
+            return getResult_currentCache([]);
+        }
+        const zSemVer = (() => {
+            const zTargetType = lib.z.object({
+                major: lib.z.number(),
+                minor: lib.z.number(),
+                patch: lib.z.number(),
+                rc: lib.z.number().optional(),
+                parsedFrom: lib.z.string()
+            });
+            (0,assert.assert)();
+            return (0,id.id)(zTargetType);
+        })();
+        const zCache = (() => {
+            const zTargetType = lib.z.object({
+                version: lib.z.literal(CACHE_VERSION),
+                entries: lib.z.array(lib.z.object({
+                    time: lib.z.number(),
+                    params: lib.z.object({
+                        owner: lib.z.string(),
+                        repo: lib.z.string(),
+                        count: lib.z.number(),
+                        doIgnoreReleaseCandidates: lib.z.boolean()
+                    }),
+                    result: lib.z.array(lib.z.object({
+                        tag: lib.z.string(),
+                        version: zSemVer
+                    }))
+                }))
+            });
+            (0,assert.assert)();
+            return (0,id.id)(zTargetType);
+        })();
+        let cache;
+        try {
+            cache = zCache.parse(cache_json_parsed);
+        }
+        catch (_c) {
+            return getResult_currentCache([]);
+        }
+        const cacheEntry = cache.entries.find(e => (0,same.same)(e.params, params));
+        if (cacheEntry === undefined) {
+            return getResult_currentCache(cache.entries);
+        }
+        if (Date.now() - cacheEntry.time > 3600000) {
+            return getResult_currentCache(cache.entries.filter(e => e !== cacheEntry));
+        }
+        return {
+            hasCachedResult: true,
+            cachedResult: cacheEntry.result
+        };
+    })();
+    if (cacheLookupResult.hasCachedResult) {
+        return cacheLookupResult.cachedResult;
+    }
+    const { currentCache } = cacheLookupResult;
+    getLatestsSemVersionedTag_stateless !== null && getLatestsSemVersionedTag_stateless !== void 0 ? getLatestsSemVersionedTag_stateless : (getLatestsSemVersionedTag_stateless = (() => {
+        const octokit = (() => {
             const githubToken = process.env.GITHUB_TOKEN;
-            const octokit = new dist_node.Octokit(githubToken === undefined ? undefined : { auth: githubToken });
-            return { octokit };
+            const octokit = new dist_node.Octokit(Object.assign(Object.assign({}, (githubToken === undefined ? {} : { auth: githubToken })), { request: {
+                    fetch: (url, options) => lib_default()(url, Object.assign(Object.assign({}, options), buildContext.fetchOptions))
+                } }));
+            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 });
-            }
+        return getLatestsSemVersionedTag;
+    })());
+    const result = await getLatestsSemVersionedTag_stateless(params);
+    currentCache.entries.push({
+        time: Date.now(),
+        params,
+        result
+    });
+    {
+        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;
-    })();
+    }
+    external_fs_.writeFileSync(cacheFilePath, JSON.stringify(currentCache, null, 2));
+    return result;
+}
+//# sourceMappingURL=getLatestsSemVersionedTag.js.map
+
+/***/ }),
+
+/***/ 82635:
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   "s": () => (/* binding */ promptKeycloakVersion)
+/* harmony export */ });
+/* harmony import */ var _getLatestsSemVersionedTag__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(97189);
+/* harmony import */ var cli_select__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(99398);
+/* harmony import */ var cli_select__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(cli_select__WEBPACK_IMPORTED_MODULE_1__);
+/* harmony import */ var tsafe_assert__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(88078);
+/* harmony import */ var tsafe_assert__WEBPACK_IMPORTED_MODULE_2___default = /*#__PURE__*/__webpack_require__.n(tsafe_assert__WEBPACK_IMPORTED_MODULE_2__);
+/* harmony import */ var _tools_SemVer__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(12171);
+
+
+
+
+(0,tsafe_assert__WEBPACK_IMPORTED_MODULE_2__.assert)();
+async function promptKeycloakVersion(params) {
+    const { startingFromMajor, excludeMajorVersions, buildContext } = params;
+    const semVersionedTagByMajor = new Map();
+    const semVersionedTags = await (0,_getLatestsSemVersionedTag__WEBPACK_IMPORTED_MODULE_0__/* .getLatestsSemVersionedTag */ ._)({
+        count: 50,
+        owner: "keycloak",
+        repo: "keycloak",
+        doIgnoreReleaseCandidates: true,
+        buildContext
+    });
     semVersionedTags.forEach(semVersionedTag => {
         if (startingFromMajor !== undefined &&
             semVersionedTag.version.major < startingFromMajor) {
@@ -192,13 +311,13 @@ async function promptKeycloakVersion(params) {
         }
         const currentSemVersionedTag = semVersionedTagByMajor.get(semVersionedTag.version.major);
         if (currentSemVersionedTag !== undefined &&
-            SemVer/* SemVer.compare */.h.compare(semVersionedTag.version, currentSemVersionedTag.version) === -1) {
+            _tools_SemVer__WEBPACK_IMPORTED_MODULE_3__/* .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()({
+    const lastMajorVersions = Array.from(semVersionedTagByMajor.values()).map(({ version }) => `${version.major}.${version.minor}`);
+    const { value } = await cli_select__WEBPACK_IMPORTED_MODULE_1___default()({
         values: lastMajorVersions
     }).catch(() => {
         process.exit(-1);
@@ -225,8 +344,8 @@ __webpack_require__.d(__webpack_exports__, {
 var shared_buildContext = __webpack_require__(56031);
 // 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/promptKeycloakVersion.js
+var promptKeycloakVersion = __webpack_require__(82635);
 // EXTERNAL MODULE: ./dist/bin/shared/constants.js
 var constants = __webpack_require__(173);
 // EXTERNAL MODULE: ./dist/bin/tools/SemVer.js
@@ -266,10 +385,12 @@ var Deferred = __webpack_require__(50689);
 
 
 
+
+
 (0,assert.assert)();
 async function appBuild(params) {
     const { buildContext } = params;
-    switch (buildContext.bundler.type) {
+    switch (buildContext.bundler) {
         case "vite":
             return appBuild_vite({ buildContext });
         case "webpack":
@@ -278,9 +399,9 @@ async function appBuild(params) {
 }
 async function appBuild_vite(params) {
     const { buildContext } = params;
-    (0,assert.assert)(buildContext.bundler.type === "vite");
+    (0,assert.assert)(buildContext.bundler === "vite");
     const dIsSuccess = new Deferred.Deferred();
-    console.log(source_default().blue("Running: 'npx vite build'"));
+    console.log(source_default().blue("$ npx vite build"));
     const child = external_child_process_.spawn("npx", ["vite", "build"], {
         cwd: buildContext.projectDirPath,
         shell: true
@@ -297,12 +418,14 @@ async function appBuild_vite(params) {
     return { isAppBuildSuccess: isSuccess };
 }
 async function appBuild_webpack(params) {
+    var _a;
     const { buildContext } = params;
-    (0,assert.assert)(buildContext.bundler.type === "webpack");
-    const entries = Object.entries(buildContext.bundler.packageJsonScripts).filter(([, scriptCommand]) => scriptCommand.includes("keycloakify build"));
+    (0,assert.assert)(buildContext.bundler === "webpack");
+    const entries = Object.entries(((_a = JSON.parse(external_fs_.readFileSync(buildContext.packageJsonFilePath).toString("utf8"))
+        .scripts) !== null && _a !== void 0 ? _a : {})).filter(([, scriptCommand]) => scriptCommand.includes("keycloakify build"));
     if (entries.length === 0) {
         console.log(source_default().red([
-            `You should have a script in your package.json at ${buildContext.bundler.packageJsonDirPath}`,
+            `You should have a script in your package.json at ${(0,external_path_.relative)(process.cwd(), (0,external_path_.dirname)(buildContext.packageJsonFilePath))}`,
             `that includes the 'keycloakify build' command`
         ].join(" ")));
         process.exit(-1);
@@ -329,7 +452,7 @@ async function appBuild_webpack(params) {
         console.log(source_default().red(`Your ${scriptName} script should look like "... && keycloakify build ..."`));
         process.exit(-1);
     }
-    let commandCwd = buildContext.bundler.packageJsonDirPath;
+    let commandCwd = (0,external_path_.dirname)(buildContext.packageJsonFilePath);
     for (const subCommand of appBuildSubCommands) {
         const dIsSuccess = new Deferred.Deferred();
         const [command, ...args] = subCommand.split(" ");
@@ -341,14 +464,14 @@ async function appBuild_webpack(params) {
             });
             continue;
         }
-        console.log(source_default().blue(`Running: '${subCommand}'`));
+        console.log(source_default().blue(`$ ${subCommand}`));
         const child = external_child_process_.spawn(command, args, {
             cwd: commandCwd,
             env: Object.assign(Object.assign({}, process.env), { PATH: (() => {
                     var _a;
                     const separator = external_path_.sep === "/" ? ":" : ";";
                     return [
-                        (0,external_path_.join)(buildContext.bundler.packageJsonDirPath, "node_modules", ".bin"),
+                        (0,external_path_.join)((0,external_path_.dirname)(buildContext.packageJsonFilePath), "node_modules", ".bin"),
                         ...((_a = process.env.PATH) !== null && _a !== void 0 ? _a : "").split(separator)
                     ].join(separator);
                 })() }),
@@ -375,10 +498,10 @@ async function appBuild_webpack(params) {
 async function keycloakifyBuild(params) {
     const { buildForKeycloakMajorVersionNumber, buildContext } = params;
     const dResult = new Deferred.Deferred();
-    console.log(source_default().blue("Running: 'npx keycloakify build'"));
+    console.log(source_default().blue("$ npx keycloakify build"));
     const child = external_child_process_.spawn("npx", ["keycloakify", "build"], {
         cwd: buildContext.projectDirPath,
-        env: Object.assign(Object.assign({}, process.env), { [constants/* buildForKeycloakMajorVersionEnvName */.um]: `${buildForKeycloakMajorVersionNumber}` }),
+        env: Object.assign(Object.assign({}, process.env), { [constants/* BUILD_FOR_KEYCLOAK_MAJOR_VERSION_ENV_NAME */.ac]: `${buildForKeycloakMajorVersionNumber}` }),
         shell: true
     });
     child.stdout.on("data", data => process.stdout.write(data));
@@ -394,6 +517,8 @@ var isInside = __webpack_require__(90665);
 var fs_existsAsync = __webpack_require__(43765);
 // EXTERNAL MODULE: ./dist/bin/tools/fs.rm.js
 var fs_rm = __webpack_require__(8699);
+// EXTERNAL MODULE: ./dist/bin/tools/downloadAndExtractArchive.js
+var downloadAndExtractArchive = __webpack_require__(38367);
 ;// CONCATENATED MODULE: ./dist/bin/start-keycloak/start-keycloak.js
 
 
@@ -415,9 +540,11 @@ var fs_rm = __webpack_require__(8699);
 
 
 
+
 
 
 async function command(params) {
+    var _a, _b, _c, _d;
     exit_if_docker_not_installed: {
         let commandOutput = undefined;
         try {
@@ -425,7 +552,7 @@ async function command(params) {
                 stdio: ["ignore", "pipe", "ignore"]
             });
         }
-        catch (_a) { }
+        catch (_e) { }
         if (commandOutput === null || commandOutput === void 0 ? void 0 : commandOutput.toString("utf8").includes("Docker")) {
             break exit_if_docker_not_installed;
         }
@@ -442,7 +569,7 @@ async function command(params) {
             external_child_process_.execSync("docker info", { stdio: "ignore" });
             isDockerRunning = true;
         }
-        catch (_b) {
+        catch (_f) {
             isDockerRunning = false;
         }
         if (isDockerRunning) {
@@ -456,23 +583,45 @@ async function command(params) {
     }
     const { cliCommandOptions } = params;
     const buildContext = (0,shared_buildContext/* getBuildContext */.s)({ cliCommandOptions });
-    const { keycloakVersion } = await (async () => {
+    const { dockerImageTag } = await (async () => {
         if (cliCommandOptions.keycloakVersion !== undefined) {
+            return { dockerImageTag: cliCommandOptions.keycloakVersion };
+        }
+        if (buildContext.startKeycloakOptions.dockerImage !== undefined) {
             return {
-                keycloakVersion: cliCommandOptions.keycloakVersion,
-                keycloakMajorNumber: SemVer/* SemVer.parse */.h.parse(cliCommandOptions.keycloakVersion).major
+                dockerImageTag: buildContext.startKeycloakOptions.dockerImage.tag
             };
         }
-        console.log(source_default().cyan("On which version of Keycloak do you want to test your theme?"));
+        console.log([
+            source_default().cyan("On which version of Keycloak do you want to test your theme?"),
+            source_default().gray("You can also explicitly provide the version with `npx keycloakify start-keycloak --keycloak-version 25.0.2` (or any other version)")
+        ].join("\n"));
         const { keycloakVersion } = await (0,promptKeycloakVersion/* promptKeycloakVersion */.s)({
             startingFromMajor: 18,
             excludeMajorVersions: [22],
-            cacheDirPath: buildContext.cacheDirPath
+            buildContext
         });
         console.log(`→ ${keycloakVersion}`);
-        return { keycloakVersion };
+        return { dockerImageTag: keycloakVersion };
+    })();
+    const keycloakMajorVersionNumber = (() => {
+        if (buildContext.startKeycloakOptions.dockerImage === undefined) {
+            return SemVer/* SemVer.parse */.h.parse(dockerImageTag).major;
+        }
+        const { tag } = buildContext.startKeycloakOptions.dockerImage;
+        const [wrap] = [18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28]
+            .map(majorVersionNumber => ({
+            majorVersionNumber,
+            index: tag.indexOf(`${majorVersionNumber}`)
+        }))
+            .filter(({ index }) => index !== -1)
+            .sort((a, b) => a.index - b.index);
+        if (wrap === undefined) {
+            console.warn(source_default().yellow(`Could not determine the major Keycloak version number from the docker image tag ${tag}. Assuming 25`));
+            return 25;
+        }
+        return wrap.majorVersionNumber;
     })();
-    const keycloakMajorVersionNumber = SemVer/* SemVer.parse */.h.parse(keycloakVersion).major;
     {
         const { isAppBuildSuccess } = await appBuild({
             buildContext
@@ -495,26 +644,48 @@ async function command(params) {
         .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 extensionJarFilePaths = await Promise.all(buildContext.startKeycloakOptions.extensionJars.map(async (extensionJar) => {
+        switch (extensionJar.type) {
+            case "path": {
+                (0,assert.assert)(await (0,fs_existsAsync/* existsAsync */.o)(extensionJar.path), `${extensionJar.path} does not exist`);
+                return extensionJar.path;
+            }
+            case "url": {
+                const { archiveFilePath } = await (0,downloadAndExtractArchive/* downloadAndExtractArchive */.I)({
+                    cacheDirPath: buildContext.cacheDirPath,
+                    fetchOptions: buildContext.fetchOptions,
+                    url: extensionJar.url,
+                    uniqueIdOfOnArchiveFile: "no extraction",
+                    onArchiveFile: async () => { }
+                });
+                return archiveFilePath;
+            }
+        }
+        (0,assert.assert)(false);
+    }));
+    const getRealmJsonFilePath_defaultForKeycloakMajor = (keycloakMajorVersionNumber) => (0,external_path_.join)((0,getThisCodebaseRootDirPath/* getThisCodebaseRootDirPath */.e)(), "src", "bin", "start-keycloak", `myrealm-realm-${keycloakMajorVersionNumber}.json`);
     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()
             });
         }
+        if (buildContext.startKeycloakOptions.realmJsonFilePath !== undefined) {
+            (0,assert.assert)(await (0,fs_existsAsync/* existsAsync */.o)(buildContext.startKeycloakOptions.realmJsonFilePath), `${(0,external_path_.relative)(process.cwd(), buildContext.startKeycloakOptions.realmJsonFilePath)} does not exist`);
+            return buildContext.startKeycloakOptions.realmJsonFilePath;
+        }
         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;
+            const defaultFilePath = getRealmJsonFilePath_defaultForKeycloakMajor(keycloakMajorVersionNumber);
+            if (external_fs_.existsSync(defaultFilePath)) {
+                return defaultFilePath;
             }
             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 dirPath = (0,external_path_.dirname)(defaultFilePath);
             const { value } = await dist_default()({
                 values: [
                     ...external_fs_.readdirSync(dirPath)
@@ -538,6 +709,25 @@ async function command(params) {
             .replace(/keycloakify\-starter/g, buildContext.themeNames[0])), "utf8");
         return filePath;
     })();
+    add_test_user_if_missing: {
+        if (realmJsonFilePath === undefined) {
+            break add_test_user_if_missing;
+        }
+        const realm = JSON.parse(external_fs_.readFileSync(realmJsonFilePath).toString("utf8"));
+        if (realm.users !== undefined) {
+            break add_test_user_if_missing;
+        }
+        const realmJsonFilePath_internal = (() => {
+            const filePath = getRealmJsonFilePath_defaultForKeycloakMajor(keycloakMajorVersionNumber);
+            if (!external_fs_.existsSync(filePath)) {
+                return getRealmJsonFilePath_defaultForKeycloakMajor(25);
+            }
+            return filePath;
+        })();
+        const users = JSON.parse(external_fs_.readFileSync(realmJsonFilePath_internal).toString("utf8")).users;
+        realm.users = users;
+        external_fs_.writeFileSync(realmJsonFilePath, JSON.stringify(realm, null, 2), "utf8");
+    }
     async function extractThemeResourcesFromJar() {
         await (0,extractArchive/* extractArchive */.N)({
             archiveFilePath: jarFilePath,
@@ -560,74 +750,83 @@ async function command(params) {
     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}`, {
+        external_child_process_.execSync(`docker rm --force ${constants/* CONTAINER_NAME */.sv}`, {
             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, "'\\''")}'`
+    catch (_g) { }
+    const DEFAULT_PORT = 8080;
+    const port = (_b = (_a = cliCommandOptions.port) !== null && _a !== void 0 ? _a : buildContext.startKeycloakOptions.port) !== null && _b !== void 0 ? _b : DEFAULT_PORT;
+    const SPACE_PLACEHOLDER = "SPACE_PLACEHOLDER_xKLmdPd";
+    const dockerRunArgs = [
+        `-p${SPACE_PLACEHOLDER}${port}:8080`,
+        `--name${SPACE_PLACEHOLDER}${constants/* CONTAINER_NAME */.sv}`,
+        `-e${SPACE_PLACEHOLDER}KEYCLOAK_ADMIN=admin`,
+        `-e${SPACE_PLACEHOLDER}KEYCLOAK_ADMIN_PASSWORD=admin`,
+        ...(buildContext.startKeycloakOptions.dockerExtraArgs.length === 0
+            ? []
+            : [
+                buildContext.startKeycloakOptions.dockerExtraArgs.join(SPACE_PLACEHOLDER)
+            ]),
+        ...(realmJsonFilePath === undefined
+            ? []
+            : [
+                `-v${SPACE_PLACEHOLDER}".${external_path_.sep}${(0,external_path_.relative)(process.cwd(), realmJsonFilePath)}":/opt/keycloak/data/import/myrealm-realm.json`
+            ]),
+        `-v${SPACE_PLACEHOLDER}".${external_path_.sep}${(0,external_path_.relative)(process.cwd(), jarFilePath_cacheDir)}":/opt/keycloak/providers/keycloak-theme.jar`,
+        ...extensionJarFilePaths.map(jarFilePath => `-v${SPACE_PLACEHOLDER}".${external_path_.sep}${(0,external_path_.relative)(process.cwd(), jarFilePath)}":/opt/keycloak/providers/${(0,external_path_.basename)(jarFilePath)}`),
+        ...(keycloakMajorVersionNumber <= 20
+            ? [`-e${SPACE_PLACEHOLDER}JAVA_OPTS=-Dkeycloak.profile=preview`]
+            : []),
+        ...[
+            ...buildContext.themeNames,
+            ...(external_fs_.existsSync((0,external_path_.join)(buildContext.keycloakifyBuildDirPath, "theme", constants/* ACCOUNT_V1_THEME_NAME */.ZQ))
+                ? [constants/* ACCOUNT_V1_THEME_NAME */.ZQ]
+                : [])
+        ]
+            .map(themeName => ({
+            localDirPath: (0,external_path_.join)(buildContext.keycloakifyBuildDirPath, "theme", themeName),
+            containerDirPath: `/opt/keycloak/themes/${themeName}`
+        }))
+            .map(({ localDirPath, containerDirPath }) => `-v${SPACE_PLACEHOLDER}".${external_path_.sep}${(0,external_path_.relative)(process.cwd(), localDirPath)}":${containerDirPath}:rw`),
+        ...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${SPACE_PLACEHOLDER}${name}='${envValue.replace(/'/g, "'\\''")}'`),
+        `${(_d = (_c = buildContext.startKeycloakOptions.dockerImage) === null || _c === void 0 ? void 0 : _c.reference) !== null && _d !== void 0 ? _d : "quay.io/keycloak/keycloak"}:${dockerImageTag}`,
+        "start-dev",
+        ...(21 <= keycloakMajorVersionNumber && keycloakMajorVersionNumber < 24
+            ? ["--features=declarative-user-profile"]
+            : []),
+        ...(realmJsonFilePath === undefined ? [] : ["--import-realm"]),
+        ...(buildContext.startKeycloakOptions.keycloakExtraArgs.length === 0
+            ? []
+            : [
+                buildContext.startKeycloakOptions.keycloakExtraArgs.join(SPACE_PLACEHOLDER)
             ])
-                .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);
+    console.log(source_default().blue([
+        `$ docker run \\`,
+        ...dockerRunArgs
+            .map(arg => arg.replace(new RegExp(SPACE_PLACEHOLDER, "g"), " "))
+            .map((line, i, arr) => `    ${line}${arr.length - 1 === i ? "" : " \\"}`)
+    ].join("\n")));
+    const child = external_child_process_.spawn("docker", ["run", ...dockerRunArgs.map(line => line.split(SPACE_PLACEHOLDER)).flat()], { shell: true });
     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 kcHttpRelativePath = (() => {
+            const match = buildContext.startKeycloakOptions.dockerExtraArgs
+                .join(" ")
+                .match(/KC_HTTP_RELATIVE_PATH=([^ ]+)/);
+            if (match === null) {
+                return undefined;
+            }
+            return match[1];
+        })();
         const handler = async (data) => {
             if (!data.toString("utf8").includes("Listening on: http://0.0.0.0:8080")) {
                 return;
@@ -638,13 +837,22 @@ async function command(params) {
                 "",
                 `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}`)}`,
+                `Keycloak Admin console: ${source_default().cyan.bold(`http://localhost:${port}${kcHttpRelativePath !== null && kcHttpRelativePath !== void 0 ? kcHttpRelativePath : ""}`)}`,
                 `- 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}`}`)}`,
+                `${source_default().green("➜")} ${source_default().cyan.bold((() => {
+                    const url = new URL("https://my-theme.keycloakify.dev");
+                    if (port !== DEFAULT_PORT) {
+                        url.searchParams.set("port", `${port}`);
+                    }
+                    if (kcHttpRelativePath !== undefined) {
+                        url.searchParams.set("kcHttpRelativePath", kcHttpRelativePath);
+                    }
+                    return url.href;
+                })())}`,
                 "",
                 "You can login with the following credentials:",
                 `- username: ${source_default().cyan.bold("testuser")}`,
@@ -785,6 +993,186 @@ var SemVer;
 
 /***/ }),
 
+/***/ 38367:
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   "I": () => (/* binding */ downloadAndExtractArchive)
+/* harmony export */ });
+/* harmony import */ var make_fetch_happen__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(9525);
+/* harmony import */ var make_fetch_happen__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(make_fetch_happen__WEBPACK_IMPORTED_MODULE_0__);
+/* harmony import */ var fs_promises__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(73292);
+/* harmony import */ var fs_promises__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(fs_promises__WEBPACK_IMPORTED_MODULE_1__);
+/* harmony import */ var path__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(71017);
+/* harmony import */ var path__WEBPACK_IMPORTED_MODULE_2___default = /*#__PURE__*/__webpack_require__.n(path__WEBPACK_IMPORTED_MODULE_2__);
+/* harmony import */ var tsafe_assert__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(88078);
+/* harmony import */ var tsafe_assert__WEBPACK_IMPORTED_MODULE_3___default = /*#__PURE__*/__webpack_require__.n(tsafe_assert__WEBPACK_IMPORTED_MODULE_3__);
+/* harmony import */ var _extractArchive__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(29121);
+/* harmony import */ var _fs_existsAsync__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(43765);
+/* harmony import */ var crypto__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(6113);
+/* harmony import */ var crypto__WEBPACK_IMPORTED_MODULE_6___default = /*#__PURE__*/__webpack_require__.n(crypto__WEBPACK_IMPORTED_MODULE_6__);
+/* harmony import */ var _fs_rm__WEBPACK_IMPORTED_MODULE_7__ = __webpack_require__(8699);
+
+
+
+
+
+
+
+
+async function downloadAndExtractArchive(params) {
+    var _a;
+    const { url, uniqueIdOfOnArchiveFile, onArchiveFile, cacheDirPath, fetchOptions } = params;
+    const archiveFileBasename = url.split("?")[0].split("/").reverse()[0];
+    const archiveFilePath = (0,path__WEBPACK_IMPORTED_MODULE_2__.join)(cacheDirPath, archiveFileBasename);
+    download: {
+        await (0,fs_promises__WEBPACK_IMPORTED_MODULE_1__.mkdir)((0,path__WEBPACK_IMPORTED_MODULE_2__.dirname)(archiveFilePath), { recursive: true });
+        if (await (0,_fs_existsAsync__WEBPACK_IMPORTED_MODULE_5__/* .existsAsync */ .o)(archiveFilePath)) {
+            const isDownloaded = await SuccessTracker.getIsDownloaded({
+                cacheDirPath,
+                archiveFileBasename
+            });
+            if (isDownloaded) {
+                break download;
+            }
+            await (0,fs_promises__WEBPACK_IMPORTED_MODULE_1__.unlink)(archiveFilePath);
+            await SuccessTracker.removeFromDownloaded({
+                cacheDirPath,
+                archiveFileBasename
+            });
+        }
+        const response = await make_fetch_happen__WEBPACK_IMPORTED_MODULE_0___default()(url, fetchOptions);
+        (_a = response.body) === null || _a === void 0 ? void 0 : _a.setMaxListeners(Number.MAX_VALUE);
+        (0,tsafe_assert__WEBPACK_IMPORTED_MODULE_3__.assert)(typeof response.body !== "undefined" && response.body != null);
+        await (0,fs_promises__WEBPACK_IMPORTED_MODULE_1__.writeFile)(archiveFilePath, response.body);
+        await SuccessTracker.markAsDownloaded({
+            cacheDirPath,
+            archiveFileBasename
+        });
+    }
+    const extractDirBasename = `${archiveFileBasename.replace(/\.([^.]+)$/, (...[, ext]) => `_${ext}`)}_${uniqueIdOfOnArchiveFile}_${crypto__WEBPACK_IMPORTED_MODULE_6__.createHash("sha256")
+        .update(onArchiveFile.toString())
+        .digest("hex")
+        .substring(0, 5)}`;
+    await Promise.all((await (0,fs_promises__WEBPACK_IMPORTED_MODULE_1__.readdir)(cacheDirPath))
+        .filter((() => {
+        const prefix = extractDirBasename
+            .split("_")
+            .reverse()
+            .slice(1)
+            .reverse()
+            .join("_");
+        return basename => basename !== extractDirBasename && basename.startsWith(prefix);
+    })())
+        .map(async (extractDirBasename) => {
+        await (0,_fs_rm__WEBPACK_IMPORTED_MODULE_7__.rm)((0,path__WEBPACK_IMPORTED_MODULE_2__.join)(cacheDirPath, extractDirBasename), {
+            recursive: true
+        });
+        await SuccessTracker.removeFromExtracted({
+            cacheDirPath,
+            extractDirBasename
+        });
+    }));
+    const extractedDirPath = (0,path__WEBPACK_IMPORTED_MODULE_2__.join)(cacheDirPath, extractDirBasename);
+    extract_and_transform: {
+        if (await (0,_fs_existsAsync__WEBPACK_IMPORTED_MODULE_5__/* .existsAsync */ .o)(extractedDirPath)) {
+            const isExtracted = await SuccessTracker.getIsExtracted({
+                cacheDirPath,
+                extractDirBasename
+            });
+            if (isExtracted) {
+                break extract_and_transform;
+            }
+            await (0,_fs_rm__WEBPACK_IMPORTED_MODULE_7__.rm)(extractedDirPath, { recursive: true });
+            await SuccessTracker.removeFromExtracted({
+                cacheDirPath,
+                extractDirBasename
+            });
+        }
+        await (0,_extractArchive__WEBPACK_IMPORTED_MODULE_4__/* .extractArchive */ .N)({
+            archiveFilePath,
+            onArchiveFile: async ({ relativeFilePathInArchive, readFile, writeFile }) => onArchiveFile({
+                fileRelativePath: relativeFilePathInArchive,
+                readFile,
+                writeFile: ({ fileRelativePath, modifiedData }) => writeFile({
+                    filePath: (0,path__WEBPACK_IMPORTED_MODULE_2__.join)(extractedDirPath, fileRelativePath),
+                    modifiedData
+                })
+            })
+        });
+        await SuccessTracker.markAsExtracted({
+            cacheDirPath,
+            extractDirBasename
+        });
+    }
+    return { extractedDirPath, archiveFilePath };
+}
+var SuccessTracker;
+(function (SuccessTracker) {
+    async function read(params) {
+        const { cacheDirPath } = params;
+        const filePath = (0,path__WEBPACK_IMPORTED_MODULE_2__.join)(cacheDirPath, "downloadAndExtractArchive.json");
+        if (!(await (0,_fs_existsAsync__WEBPACK_IMPORTED_MODULE_5__/* .existsAsync */ .o)(filePath))) {
+            return { archiveFileBasenames: [], extractDirBasenames: [] };
+        }
+        return JSON.parse((await (0,fs_promises__WEBPACK_IMPORTED_MODULE_1__.readFile)(filePath)).toString("utf8"));
+    }
+    async function write(params) {
+        const { cacheDirPath, successTracker } = params;
+        const filePath = (0,path__WEBPACK_IMPORTED_MODULE_2__.join)(cacheDirPath, "downloadAndExtractArchive.json");
+        {
+            const dirPath = (0,path__WEBPACK_IMPORTED_MODULE_2__.dirname)(filePath);
+            if (!(await (0,_fs_existsAsync__WEBPACK_IMPORTED_MODULE_5__/* .existsAsync */ .o)(dirPath))) {
+                await (0,fs_promises__WEBPACK_IMPORTED_MODULE_1__.mkdir)(dirPath, { recursive: true });
+            }
+        }
+        await (0,fs_promises__WEBPACK_IMPORTED_MODULE_1__.writeFile)(filePath, JSON.stringify(successTracker));
+    }
+    async function markAsDownloaded(params) {
+        const { cacheDirPath, archiveFileBasename } = params;
+        const successTracker = await read({ cacheDirPath });
+        successTracker.archiveFileBasenames.push(archiveFileBasename);
+        await write({ cacheDirPath, successTracker });
+    }
+    SuccessTracker.markAsDownloaded = markAsDownloaded;
+    async function getIsDownloaded(params) {
+        const { cacheDirPath, archiveFileBasename } = params;
+        const successTracker = await read({ cacheDirPath });
+        return successTracker.archiveFileBasenames.includes(archiveFileBasename);
+    }
+    SuccessTracker.getIsDownloaded = getIsDownloaded;
+    async function removeFromDownloaded(params) {
+        const { cacheDirPath, archiveFileBasename } = params;
+        const successTracker = await read({ cacheDirPath });
+        successTracker.archiveFileBasenames = successTracker.archiveFileBasenames.filter(basename => basename !== archiveFileBasename);
+        await write({ cacheDirPath, successTracker });
+    }
+    SuccessTracker.removeFromDownloaded = removeFromDownloaded;
+    async function markAsExtracted(params) {
+        const { cacheDirPath, extractDirBasename } = params;
+        const successTracker = await read({ cacheDirPath });
+        successTracker.extractDirBasenames.push(extractDirBasename);
+        await write({ cacheDirPath, successTracker });
+    }
+    SuccessTracker.markAsExtracted = markAsExtracted;
+    async function getIsExtracted(params) {
+        const { cacheDirPath, extractDirBasename } = params;
+        const successTracker = await read({ cacheDirPath });
+        return successTracker.extractDirBasenames.includes(extractDirBasename);
+    }
+    SuccessTracker.getIsExtracted = getIsExtracted;
+    async function removeFromExtracted(params) {
+        const { cacheDirPath, extractDirBasename } = params;
+        const successTracker = await read({ cacheDirPath });
+        successTracker.extractDirBasenames = successTracker.extractDirBasenames.filter(basename => basename !== extractDirBasename);
+        await write({ cacheDirPath, successTracker });
+    }
+    SuccessTracker.removeFromExtracted = removeFromExtracted;
+})(SuccessTracker || (SuccessTracker = {}));
+//# sourceMappingURL=downloadAndExtractArchive.js.map
+
+/***/ }),
+
 /***/ 29121:
 /***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {