keycloakify 10.0.0-rc.137 → 10.0.0-rc.138

package/bin/31.index.js

@@ -142,7 +142,7 @@ function ensureSingleOrNone(arg0) {
 
 (0,assert.assert)();
 function getBuildContext(params) {
-    var _a, _b, _c, _d, _e, _f;
+    var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o;
     const { cliCommandOptions } = params;
     const projectDirPath = cliCommandOptions.projectDirPath !== undefined
         ? (0,getAbsoluteAndInOsFormatPath/* getAbsoluteAndInOsFormatPath */.c)({
@@ -260,6 +260,17 @@ function getBuildContext(params) {
             (0,assert.assert)();
             return (0,id.id)(zTargetType);
         })();
+        const zStartKeycloakOptions = (() => {
+            const zTargetType = lib.z.object({
+                dockerImage: lib.z.string().optional(),
+                extensionJars: lib.z.array(lib.z.string()).optional(),
+                realmJsonFilePath: lib.z.string().optional(),
+                dockerExtraArgs: lib.z.array(lib.z.string()).optional(),
+                keycloakExtraArgs: lib.z.array(lib.z.string()).optional()
+            });
+            (0,assert.assert)();
+            return (0,id.id)(zTargetType);
+        })();
         const zBuildOptions = (() => {
             const zTargetType = lib.z.intersection(lib.z.object({
                 themeName: lib.z.union([lib.z.string(), lib.z.array(lib.z.string())]).optional(),
@@ -274,7 +285,8 @@ function getBuildContext(params) {
                 groupId: lib.z.string().optional(),
                 loginThemeResourcesFromKeycloakVersion: lib.z.string().optional(),
                 keycloakifyBuildDirPath: lib.z.string().optional(),
-                kcContextExclusionsFtl: lib.z.string().optional()
+                kcContextExclusionsFtl: lib.z.string().optional(),
+                startKeycloakOptions: zStartKeycloakOptions.optional()
             }), zAccountThemeImplAndKeycloakVersionTargets);
             (0,assert.assert)();
             return (0,id.id)(zTargetType);
@@ -660,7 +672,38 @@ function getBuildContext(params) {
                 process.exit(1);
             }
             return jarTargets;
-        })()
+        })(),
+        startKeycloakOptions: {
+            dockerImage: (() => {
+                var _a;
+                if (((_a = buildOptions.startKeycloakOptions) === null || _a === void 0 ? void 0 : _a.dockerImage) === undefined) {
+                    return undefined;
+                }
+                const [reference, tag, ...rest] = buildOptions.startKeycloakOptions.dockerImage.split(":");
+                (0,assert.assert)(reference !== undefined && tag !== undefined && rest.length === 0, `Invalid docker image: ${buildOptions.startKeycloakOptions.dockerImage}`);
+                return { reference, tag };
+            })(),
+            dockerExtraArgs: (_h = (_g = buildOptions.startKeycloakOptions) === null || _g === void 0 ? void 0 : _g.dockerExtraArgs) !== null && _h !== void 0 ? _h : [],
+            keycloakExtraArgs: (_k = (_j = buildOptions.startKeycloakOptions) === null || _j === void 0 ? void 0 : _j.keycloakExtraArgs) !== null && _k !== void 0 ? _k : [],
+            extensionJars: ((_m = (_l = buildOptions.startKeycloakOptions) === null || _l === void 0 ? void 0 : _l.extensionJars) !== null && _m !== void 0 ? _m : []).map(urlOrPath => {
+                if (/^https?:\/\//.test(urlOrPath)) {
+                    return { type: "url", url: urlOrPath };
+                }
+                return {
+                    type: "path",
+                    path: (0,getAbsoluteAndInOsFormatPath/* getAbsoluteAndInOsFormatPath */.c)({
+                        pathIsh: urlOrPath,
+                        cwd: projectDirPath
+                    })
+                };
+            }),
+            realmJsonFilePath: ((_o = buildOptions.startKeycloakOptions) === null || _o === void 0 ? void 0 : _o.realmJsonFilePath) === undefined
+                ? undefined
+                : (0,getAbsoluteAndInOsFormatPath/* getAbsoluteAndInOsFormatPath */.c)({
+                    pathIsh: buildOptions.startKeycloakOptions.realmJsonFilePath,
+                    cwd: projectDirPath
+                })
+        }
     };
 }
 //# sourceMappingURL=buildContext.js.map

package/bin/440.index.js

@@ -885,7 +885,7 @@ async function generateResourcesForMainTheme(params) {
             break bring_in_account_v3_i18n_messages;
         }
         const { extractedDirPath } = await (0,downloadAndExtractArchive/* downloadAndExtractArchive */.I)({
-            url: "https://repo1.maven.org/maven2/org/keycloak/keycloak-account-ui/25.0.1/keycloak-account-ui-25.0.1.jar",
+            urlOrPath: "https://repo1.maven.org/maven2/org/keycloak/keycloak-account-ui/25.0.1/keycloak-account-ui-25.0.1.jar",
             cacheDirPath: buildContext.cacheDirPath,
             fetchOptions: buildContext.fetchOptions,
             uniqueIdOfOnArchiveFile: "bring_in_account_v3_i18n_messages",

package/bin/526.index.js

@@ -401,7 +401,7 @@ async function appBuild_vite(params) {
     const { buildContext } = params;
     (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
@@ -464,7 +464,7 @@ 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: (() => {
@@ -498,7 +498,7 @@ 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/* BUILD_FOR_KEYCLOAK_MAJOR_VERSION_ENV_NAME */.ac]: `${buildForKeycloakMajorVersionNumber}` }),
@@ -517,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
 
 
@@ -538,9 +540,11 @@ var fs_rm = __webpack_require__(8699);
 
 
 
+
 
 
 async function command(params) {
+    var _a, _b;
     exit_if_docker_not_installed: {
         let commandOutput = undefined;
         try {
@@ -548,7 +552,7 @@ async function command(params) {
                 stdio: ["ignore", "pipe", "ignore"]
             });
         }
-        catch (_a) { }
+        catch (_c) { }
         if (commandOutput === null || commandOutput === void 0 ? void 0 : commandOutput.toString("utf8").includes("Docker")) {
             break exit_if_docker_not_installed;
         }
@@ -565,7 +569,7 @@ async function command(params) {
             external_child_process_.execSync("docker info", { stdio: "ignore" });
             isDockerRunning = true;
         }
-        catch (_b) {
+        catch (_d) {
             isDockerRunning = false;
         }
         if (isDockerRunning) {
@@ -579,11 +583,13 @@ 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([
@@ -596,9 +602,26 @@ async function command(params) {
             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
@@ -621,18 +644,39 @@ 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,
+                    urlOrPath: extensionJar.url,
+                    uniqueIdOfOnArchiveFile: "no extraction",
+                    onArchiveFile: async () => { }
+                });
+                return archiveFilePath;
+            }
+        }
+        (0,assert.assert)(false);
+    }));
     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`);
@@ -690,65 +734,52 @@ async function command(params) {
             stdio: "ignore"
         });
     }
-    catch (_c) { }
-    const spawnArgs = [
-        "docker",
-        [
-            "run",
-            ...["-p", `${cliCommandOptions.port}:8080`],
-            ...["--name", constants/* CONTAINER_NAME */.sv],
-            ...["-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/* 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",
-                `"${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
-        }
+    catch (_e) { }
+    const dockerRunArgs = [
+        `-p ${cliCommandOptions.port}:8080`,
+        `--name ${constants/* CONTAINER_NAME */.sv}`,
+        `-e KEYCLOAK_ADMIN=admin`,
+        `-e KEYCLOAK_ADMIN_PASSWORD=admin`,
+        ...(realmJsonFilePath === undefined
+            ? []
+            : [
+                `-v ".${external_path_.sep}${(0,external_path_.relative)(process.cwd(), realmJsonFilePath)}":/opt/keycloak/data/import/myrealm-realm.json`
+            ]),
+        `-v "./${(0,external_path_.relative)(process.cwd(), jarFilePath_cacheDir)}":/opt/keycloak/providers/keycloak-theme.jar`,
+        ...extensionJarFilePaths.map(jarFilePath => `-v ".${external_path_.sep}${(0,external_path_.relative)(process.cwd(), jarFilePath)}":/opt/keycloak/providers/${(0,external_path_.basename)(jarFilePath)}`),
+        ...(keycloakMajorVersionNumber <= 20
+            ? ["-e 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 ".${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 ${name}='${envValue.replace(/'/g, "'\\''")}'`),
+        ...buildContext.startKeycloakOptions.dockerExtraArgs,
+        `${(_b = (_a = buildContext.startKeycloakOptions.dockerImage) === null || _a === void 0 ? void 0 : _a.reference) !== null && _b !== void 0 ? _b : "quay.io/keycloak/keycloak"}:${dockerImageTag}`,
+        "start-dev",
+        ...(21 <= keycloakMajorVersionNumber && keycloakMajorVersionNumber < 24
+            ? ["--features=declarative-user-profile"]
+            : []),
+        ...(realmJsonFilePath === undefined ? [] : ["--import-realm"]),
+        ...buildContext.startKeycloakOptions.keycloakExtraArgs
     ];
-    const child = external_child_process_.spawn(...spawnArgs);
+    console.log(source_default().blue([
+        `$ docker run \\`,
+        ...dockerRunArgs.map((line, i, arr) => `    ${line}${arr.length - 1 === i ? "" : " \\"}`)
+    ].join("\n")));
+    const child = external_child_process_.spawn("docker", ["run", ...dockerRunArgs.map(line => line.split(" ")).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);
@@ -911,6 +942,195 @@ 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 { urlOrPath, uniqueIdOfOnArchiveFile, onArchiveFile, cacheDirPath, fetchOptions } = params;
+    const isUrl = /^https?:\/\//.test(urlOrPath);
+    const archiveFileBasename = isUrl
+        ? urlOrPath.split("?")[0].split("/").reverse()[0]
+        : (0,path__WEBPACK_IMPORTED_MODULE_2__.basename)(urlOrPath);
+    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 (!isUrl) {
+            await fs_promises__WEBPACK_IMPORTED_MODULE_1__.copyFile(urlOrPath, archiveFilePath);
+            break download;
+        }
+        const url = urlOrPath;
+        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__) => {
 

package/bin/622.index.js

@@ -25,7 +25,7 @@ async function downloadKeycloakDefaultTheme(params) {
     let kcNodeModulesKeepFilePaths = undefined;
     let kcNodeModulesKeepFilePaths_lastAccountV1 = undefined;
     const { extractedDirPath } = await (0,_tools_downloadAndExtractArchive__WEBPACK_IMPORTED_MODULE_3__/* .downloadAndExtractArchive */ .I)({
-        url: `https://repo1.maven.org/maven2/org/keycloak/keycloak-themes/${keycloakVersion}/keycloak-themes-${keycloakVersion}.jar`,
+        urlOrPath: `https://repo1.maven.org/maven2/org/keycloak/keycloak-themes/${keycloakVersion}/keycloak-themes-${keycloakVersion}.jar`,
         cacheDirPath: buildContext.cacheDirPath,
         fetchOptions: buildContext.fetchOptions,
         uniqueIdOfOnArchiveFile: "downloadKeycloakDefaultTheme",
@@ -262,12 +262,22 @@ var SemVer;
 
 
 
+
 async function downloadAndExtractArchive(params) {
     var _a;
-    const { url, uniqueIdOfOnArchiveFile, onArchiveFile, cacheDirPath, fetchOptions } = params;
-    const archiveFileBasename = url.split("?")[0].split("/").reverse()[0];
+    const { urlOrPath, uniqueIdOfOnArchiveFile, onArchiveFile, cacheDirPath, fetchOptions } = params;
+    const isUrl = /^https?:\/\//.test(urlOrPath);
+    const archiveFileBasename = isUrl
+        ? urlOrPath.split("?")[0].split("/").reverse()[0]
+        : (0,path__WEBPACK_IMPORTED_MODULE_2__.basename)(urlOrPath);
     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 (!isUrl) {
+            await fs_promises__WEBPACK_IMPORTED_MODULE_1__.copyFile(urlOrPath, archiveFilePath);
+            break download;
+        }
+        const url = urlOrPath;
         if (await (0,_fs_existsAsync__WEBPACK_IMPORTED_MODULE_5__/* .existsAsync */ .o)(archiveFilePath)) {
             const isDownloaded = await SuccessTracker.getIsDownloaded({
                 cacheDirPath,
@@ -282,7 +292,6 @@ async function downloadAndExtractArchive(params) {
                 archiveFileBasename
             });
         }
-        await (0,fs_promises__WEBPACK_IMPORTED_MODULE_1__.mkdir)((0,path__WEBPACK_IMPORTED_MODULE_2__.dirname)(archiveFilePath), { recursive: true });
         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);
@@ -347,7 +356,7 @@ async function downloadAndExtractArchive(params) {
             extractDirBasename
         });
     }
-    return { extractedDirPath };
+    return { extractedDirPath, archiveFilePath };
 }
 var SuccessTracker;
 (function (SuccessTracker) {

package/bin/shared/buildContext.d.ts

@@ -45,6 +45,22 @@ export type BuildContext = {
         keycloakVersionRange: KeycloakVersionRange;
         jarFileBasename: string;
     }[];
+    startKeycloakOptions: {
+        dockerImage: {
+            reference: string;
+            tag: string;
+        } | undefined;
+        dockerExtraArgs: string[];
+        keycloakExtraArgs: string[];
+        extensionJars: ({
+            type: "path";
+            path: string;
+        } | {
+            type: "url";
+            url: string;
+        })[];
+        realmJsonFilePath: string | undefined;
+    };
 };
 export type BuildOptions = {
     themeName?: string | string[];
@@ -59,6 +75,13 @@ export type BuildOptions = {
     loginThemeResourcesFromKeycloakVersion?: string;
     keycloakifyBuildDirPath?: string;
     kcContextExclusionsFtl?: string;
+    startKeycloakOptions?: {
+        dockerImage?: string;
+        dockerExtraArgs?: string[];
+        keycloakExtraArgs?: string[];
+        extensionJars?: string[];
+        realmJsonFilePath?: string;
+    };
 } & BuildOptions.AccountThemeImplAndKeycloakVersionTargets;
 export declare namespace BuildOptions {
     type AccountThemeImplAndKeycloakVersionTargets = AccountThemeImplAndKeycloakVersionTargets.MultiPageApp | AccountThemeImplAndKeycloakVersionTargets.SinglePageAppOrNone;