@raisenow/tamaro-cli 1.8.0 → 1.9.0-dev.1

package/README.md

@@ -185,7 +185,9 @@ Deploy a pre-built _Tamaro Core_ or customer configuration bundle to AWS S3.
 
 ### Options
 
+- `--dryrun` – Displays the operations that would be performed without actually running them
 - `--tag <tag>` – Tag which should be used for the deployment of the bundle (default: "latest")
+- `--skip-epms-sync-only-use-in-emergencies-or-you-will-be-fired` – Skip the EPMS sync entirely. Only use this in emergencies.
 
 Make sure you have built the bundle before deploying it with this command, otherwise you may mistakenly deploy the
 bundle from a previous build.
@@ -287,6 +289,15 @@ cd /path/to/tamaro-configurations/configs/example-02-typical-customisations
 npx -y @raisenow/tamaro-cli undeploy-email-config
 ```
 
+## `update-epms`
+
+Sync the Tamaro configuration with EPMS (without deploying it). 
+
+## Options
+
+- `--dryrun` – Displays the operations that would be performed without actually running them
+- `--tag <tag>` – Tag which should be used for the deployment of the bundle (default: "latest")
+
 ## `archive`
 
 Archive a customer configuration. This moves the configuration folder into the `_archived` folder.

package/dist/cli.js

@@ -1,15 +1,23 @@
 #!/usr/bin/env node
-import { C as promptConfirmation, D as logError, E as logDataTable, O as logSuccess, S as halt, T as logCommand, _ as getWidgetUuid, a as AWS_S3_BUCKET_TAMARO, c as CORE_CONFIG_NAME, d as HTTPS_CRT_FILE, f as HTTPS_KEY_FILE, h as getPaths, i as AWS_CLOUDFRONT_DISTRIBUTION_ID, k as logTitle, l as DEFAULT_PORT, m as getIfCoreFns, n as assertEnvValid, o as AWS_S3_BUCKET_TAMARO_EMAIL_CONFIG_PROD, s as AWS_S3_BUCKET_TAMARO_EMAIL_CONFIG_STAGE, t as applyEnv, u as DEFAULT_TAG, w as runCommandSync, x as resolveOwn, y as resolveBin } from "./env-CSg7BrvF.js";
+import { A as EPMS_AUTH_CLIENT_ID_STAGE, B as logSuccess, C as DEFAULT_PORT, D as EPMS_AUTH_BASE_URL_PROD, E as EPMS_API_BASE_URL_STAGE, F as runCommandSync, I as createTerminalLink, L as logCommand, M as HTTPS_KEY_FILE, N as halt, O as EPMS_AUTH_BASE_URL_STAGE, P as promptConfirmation, R as logDataTable, S as DEFAULT_HTTP_TIMEOUT, T as EPMS_API_BASE_URL_PROD, V as logTitle, _ as AWS_S3_BUCKET_TAMARO, a as getIfCoreFns, b as CACHE_DIR, c as getWidgetUuid, d as resolveBin, f as resolveCoreVersion, g as AWS_CLOUDFRONT_DISTRIBUTION_ID, h as AUTH_PORT, j as HTTPS_CRT_FILE, k as EPMS_AUTH_CLIENT_ID_PROD, l as resolveAccountUuidFromConfig, m as resolveOwn, n as assertEnvValid, o as getPaths, t as applyEnv, v as AWS_S3_BUCKET_TAMARO_EMAIL_CONFIG_PROD, w as DEFAULT_TAG, x as CORE_CONFIG_NAME, y as AWS_S3_BUCKET_TAMARO_EMAIL_CONFIG_STAGE, z as logError } from "./env-JzPIlctP.js";
 import { createCommand } from "commander";
-import fs, { existsSync, mkdirSync, renameSync } from "node:fs";
+import fs, { existsSync, mkdirSync, readFileSync, renameSync, writeFileSync } from "node:fs";
 import path from "node:path";
+import { S3 } from "@aws-sdk/client-s3";
 import { execaCommandSync } from "execa";
 import prompts from "prompts";
 import stripIndent from "strip-indent";
+import columnify from "columnify";
 import notifier from "node-notifier";
+import { z } from "zod";
 import { globSync } from "glob";
 import Handlebars from "handlebars";
 import helpers from "handlebars-helpers";
+import { config } from "dotenv";
+import * as yaml from "js-yaml";
+import ky from "ky";
+import { createServer } from "node:http";
+import open from "open";
 import { getPortPromise } from "portfinder";
 //#region src/lib/aws.ts
 const awsAuthenticate = (options) => {
@@ -83,6 +91,28 @@ const promptProfile = async () => {
 	}], { onCancel: () => halt() });
 	return profile;
 };
+const s3 = new S3({});
+const getConfigDeployments = async (configName) => {
+	const widgetJs = (await s3.listObjectsV2({
+		Bucket: "tamaro.raisenow.com",
+		Prefix: `${configName}/`
+	})).Contents?.filter((file) => file.Key?.endsWith(`/index.html`)) ?? [];
+	const deployments = [];
+	for (const file of widgetJs) {
+		const key = file.Key ?? "";
+		const parts = key.split("/");
+		if (parts.length < 2 || !file.LastModified) continue;
+		const tag = parts.at(-2);
+		const date = file.LastModified.toISOString();
+		const fullUrl = `https://${AWS_S3_BUCKET_TAMARO}/${key}`;
+		deployments.push({
+			date,
+			fullUrl,
+			tag
+		});
+	}
+	return deployments;
+};
 //#endregion
 //#region src/lib/notifier.ts
 const notify = (args) => {
@@ -98,7 +128,7 @@ const notify = (args) => {
 //#region src/commands/archive.ts
 const archive = (options) => {
 	const { ifCore } = getIfCoreFns();
-	assertIsNotCore$3(ifCore);
+	assertIsNotCore$4(ifCore);
 	assertIsNotArchived();
 	const configName = getWidgetUuid();
 	const cwd = process.cwd();
@@ -124,7 +154,7 @@ const assertOptionsValid$9 = (options) => {
 	const { profile } = options;
 	if (profile) assertProfileValid(profile);
 };
-const assertIsNotCore$3 = (ifCore) => {
+const assertIsNotCore$4 = (ifCore) => {
 	if (ifCore()) halt("You cannot archive Tamaro Core.");
 };
 const assertIsNotArchived = () => {
@@ -324,6 +354,311 @@ const assertTagValid = (tag) => {
 	if (!regex.test(tag)) halt(`Flag "--tag" has forbidden format. Allowed format: ${regex.toString()}.`);
 };
 //#endregion
+//#region src/lib/epms/auth/util.ts
+const CachedTokenSchema = z.object({
+	expirationTime: z.number(),
+	token: z.string()
+});
+const AuthResponseSchema = z.object({
+	access_token: z.string(),
+	expires_in: z.number(),
+	token_type: z.string()
+});
+const getCacheFilePath = (baseUrl, clientId) => {
+	const cacheKey = Buffer.from(`${baseUrl}|${clientId}`).toString("base64url");
+	return path.join(CACHE_DIR, `token-${cacheKey}.json`);
+};
+const readCachedToken = (baseUrl, clientId) => {
+	try {
+		const filePath = getCacheFilePath(baseUrl, clientId);
+		if (!existsSync(filePath)) return;
+		const data = JSON.parse(readFileSync(filePath, "utf8"));
+		const parsed = CachedTokenSchema.safeParse(data);
+		if (parsed.success) return parsed.data;
+	} catch {}
+};
+const writeCachedToken = (baseUrl, clientId, cached) => {
+	try {
+		const filePath = getCacheFilePath(baseUrl, clientId);
+		mkdirSync(path.dirname(filePath), { recursive: true });
+		writeFileSync(filePath, JSON.stringify(cached), { mode: 384 });
+	} catch {}
+};
+const removeCachedToken = (baseUrl, clientId) => {
+	try {
+		const filePath = getCacheFilePath(baseUrl, clientId);
+		if (existsSync(filePath)) writeFileSync(filePath, "", { flag: "w" });
+	} catch {}
+};
+//#endregion
+//#region src/lib/epms/auth/apiClient.ts
+const createAuthorizer = (baseUrl, clientId, clientSecret) => {
+	const apiUnauthorized = ky.extend({
+		headers: { "Access-Control-Allow-Origin": "*" },
+		prefixUrl: baseUrl,
+		timeout: DEFAULT_HTTP_TIMEOUT
+	});
+	let expirationTime = void 0;
+	let token = void 0;
+	const cached = readCachedToken(baseUrl, clientId);
+	if (cached) {
+		token = cached.token;
+		expirationTime = cached.expirationTime;
+	}
+	const authorize = async () => {
+		const isExpired = (expirationTime ?? 0) - Date.now() < 300 * 1e3;
+		if (token && !isExpired) return token;
+		const data = await apiUnauthorized.post("oauth2/token", { json: {
+			client_id: clientId,
+			client_secret: clientSecret,
+			grant_type: "client_credentials"
+		} }).json();
+		token = `${data.token_type} ${data.access_token}`;
+		expirationTime = Date.now() + data.expires_in * 1e3;
+		writeCachedToken(baseUrl, clientId, {
+			expirationTime,
+			token
+		});
+		return token;
+	};
+	return apiUnauthorized.extend({ hooks: { beforeRequest: [async (request) => {
+		const authToken = await authorize();
+		request.headers.set("Authorization", authToken);
+	}] } });
+};
+//#endregion
+//#region src/lib/epms/auth/authCallback.html
+var authCallback_default = "<!doctype html>\n<html>\n  <head\n    ><title>Authenticating</title></head\n  >\n  <body>\n    <p>Authenticating</p>\n    <script>\n      const hash = window.location.hash.substring(1)\n      const params = new URLSearchParams(hash)\n      const data = {\n        access_token: params.get('access_token'),\n        token_type: params.get('token_type'),\n        expires_in: parseInt(params.get('expires_in') || '0', 10),\n      }\n      fetch('/token', {\n        method: 'POST',\n        headers: {'Content-Type': 'application/json'},\n        body: JSON.stringify(data),\n      })\n        .then(() => {\n          document.querySelector('p').textContent =\n            'Authentication successful! You can close this tab.'\n        })\n        .catch(() => {\n          document.querySelector('p').textContent =\n            'Authentication failed. Please try again.'\n        })\n    <\/script>\n  </body>\n</html>\n";
+//#endregion
+//#region src/lib/epms/auth/browser.ts
+/**
+* The following authentication method is a browser-based OAuth flow.
+* A very similar flow is used by tools like AWS CLI when running `aws sso login` or Claude Code.
+*
+* The flow works as follows:
+* 1. The CLI starts a temporary local HTTP server that listens for the OAuth callback.
+* 2. The CLI opens the user's default web browser and navigates to the EPMS authorization URL, passing the local server's callback URL as the redirect_uri.
+* 3. The user authenticates in the browser, and the OAuth server redirects back to the local server with the authorization token.
+* 4. The local server captures the token and resolves the promise, completing the authentication flow.
+*
+*
+* We also implement a simple caching mechanism that stores the token in a file in the user's home directory.
+* This allows us to reuse the token for subsequent requests until it expires, at which point we automatically trigger a new authentication flow.
+*/
+const doBrowserOAuthFlow = (authBaseUrl, clientId, port) => {
+	return new Promise((resolve, reject) => {
+		const server = createServer((req, res) => {
+			if (req.method === "POST" && req.url === "/token") {
+				let body = "";
+				req.on("data", (chunk) => {
+					body += chunk.toString();
+				});
+				req.on("end", () => {
+					try {
+						const data = AuthResponseSchema.parse(JSON.parse(body));
+						res.writeHead(200);
+						res.end();
+						server.close();
+						resolve(data);
+					} catch (error) {
+						res.writeHead(400);
+						res.end();
+						reject(error instanceof Error ? error : new Error(String(error)));
+					}
+				});
+			} else {
+				res.writeHead(200, { "Content-Type": "text/html" });
+				res.end(authCallback_default);
+			}
+		});
+		server.on("error", reject);
+		server.listen(port, () => {
+			const redirectUri = `http://localhost:${port}`;
+			const authUrl = `${authBaseUrl}/oauth2/authorize?client_id=${encodeURIComponent(clientId)}&redirect_uri=${encodeURIComponent(redirectUri)}&response_type=token`;
+			console.log(`Opening browser for authentication: ${authUrl}`);
+			open(authUrl).catch((error) => {
+				reject(error instanceof Error ? error : new Error(String(error)));
+			});
+		});
+	});
+};
+const createBrowserAuthorizer = (authBaseUrl, clientId, epmsBaseUrl) => {
+	const apiBase = ky.extend({
+		prefixUrl: epmsBaseUrl,
+		timeout: DEFAULT_HTTP_TIMEOUT
+	});
+	let expirationTime = void 0;
+	let token = void 0;
+	const cacheBaseUrl = `browser|${authBaseUrl}`;
+	const cached = readCachedToken(cacheBaseUrl, clientId);
+	if (cached) {
+		token = cached.token;
+		expirationTime = cached.expirationTime;
+	}
+	const resetAuth = () => {
+		token = void 0;
+		expirationTime = void 0;
+		removeCachedToken(cacheBaseUrl, clientId);
+	};
+	const authorize = async () => {
+		const isExpired = (expirationTime ?? 0) - Date.now() < 300 * 1e3;
+		if (token && !isExpired) return token;
+		const data = await doBrowserOAuthFlow(authBaseUrl, clientId, AUTH_PORT);
+		token = `${data.token_type} ${data.access_token}`;
+		expirationTime = Date.now() + data.expires_in * 1e3;
+		writeCachedToken(cacheBaseUrl, clientId, {
+			expirationTime,
+			token
+		});
+		return token;
+	};
+	return apiBase.extend({ hooks: {
+		afterResponse: [async (request, options, response) => {
+			if (response.status === 401) {
+				resetAuth();
+				const newToken = await authorize();
+				const newRequest = new Request(request, { headers: new Headers(request.headers) });
+				newRequest.headers.set("Authorization", newToken);
+				return ky(newRequest, options);
+			}
+			return response;
+		}],
+		beforeRequest: [async (request) => {
+			const authToken = await authorize();
+			request.headers.set("Authorization", authToken);
+		}]
+	} });
+};
+//#endregion
+//#region src/lib/epms/client.ts
+var EpmsClient = class EpmsClient {
+	#epmsClient;
+	constructor(epmsClient) {
+		this.#epmsClient = epmsClient;
+	}
+	static fromClientCredentials(baseUrl, clientId, clientSecret) {
+		return new EpmsClient(createAuthorizer(baseUrl, clientId, clientSecret));
+	}
+	static fromBrowserAuth(epmsBaseUrl, authBaseUrl, clientId) {
+		return new EpmsClient(createBrowserAuthorizer(authBaseUrl, clientId, epmsBaseUrl));
+	}
+	async getOrganisationIdByAccountUuid(accountUuid) {
+		const query = {
+			from: 0,
+			query: { $and: [{ $term: { object_uuid: accountUuid } }, { $term: { object: "account" } }] },
+			size: 1
+		};
+		const response = await this.#epmsClient.post("search/events", { json: query }).json();
+		if (response.hits.length === 0) throw new Error(`No events found for account UUID: ${accountUuid}`);
+		const organisationId = response.hits[0].organisation_uuid;
+		if (!organisationId) throw new Error(`Organisation UUID not found for account UUID: ${accountUuid}`);
+		return organisationId;
+	}
+	async updateTamaro(configName, tag, json) {
+		return this.#epmsClient.put(`products/tamaro/${configName}/tags/${tag}`, { json }).json();
+	}
+};
+//#endregion
+//#region src/commands/update-epms.ts
+const updateEpms = async (options) => {
+	const { ifCore } = getIfCoreFns();
+	assertIsNotCore$3(ifCore);
+	if (!options.profile && !options.ci) {
+		assertProfilesPresent();
+		options.profile = await promptProfile();
+	}
+	if (options.profile) {
+		assertProfileValid(options.profile);
+		process.env.AWS_PROFILE = options.profile;
+	}
+	awsAuthenticate(options);
+	const paths = getPaths(ifCore);
+	const { dryrun, tag } = options;
+	const configName = getWidgetUuid();
+	loadEnv(paths);
+	const { accountUuidsProd, accountUuidsStage } = loadAccountUuidsFromConfig(paths);
+	if (dryrun) logTitle("🧪 DRY RUN MODE - No actual changes will be made 🧪");
+	const configuredVersion = resolveCoreVersion();
+	if (!configuredVersion) {
+		logTitle("⚠️ Could not determine the configured Tamaro version. Please ensure that the CORE_VERSION environment variable is set or that the CORE_URL environment variable contains a valid Tamaro version.");
+		logTitle("This may be expected behaviour if you are using a custom build of Tamaro Core. If so, you can safely ignore this warning. ⚠️");
+	}
+	const baseInfo = {
+		configured_version: configuredVersion ?? "unknown",
+		last_deployment: Math.trunc(Date.now() / 1e3),
+		read_only: false
+	};
+	for (const accountUuidStage of accountUuidsStage) if (accountUuidStage) {
+		const epmsClient = epmsAuthenticate("stage");
+		const organisationUuid = await epmsClient.getOrganisationIdByAccountUuid(accountUuidStage);
+		const body = {
+			...baseInfo,
+			account_uuid: accountUuidStage,
+			organisation_uuid: organisationUuid
+		};
+		logTitle(`Updating EPMS Stage for tag "${tag}":`);
+		logDataTable({
+			name: configName,
+			tag,
+			...body
+		});
+		if (!dryrun) {
+			await epmsClient.updateTamaro(configName, tag, body);
+			logSuccess("✅ EPMS Stage is updated.");
+		} else logSuccess("⏭️ EPMS Stage would be updated (dry run).");
+	}
+	for (const accountUuidProd of accountUuidsProd) if (accountUuidProd) {
+		const epmsClient = epmsAuthenticate("prod");
+		const organisationUuid = await epmsClient.getOrganisationIdByAccountUuid(accountUuidProd);
+		logTitle(`Updating EPMS Prod for tag "${tag}":`);
+		const body = {
+			...baseInfo,
+			account_uuid: accountUuidProd,
+			organisation_uuid: organisationUuid
+		};
+		logDataTable({
+			name: configName,
+			tag,
+			...body
+		});
+		if (!dryrun) {
+			await epmsClient.updateTamaro(configName, tag, body);
+			logSuccess("✅ EPMS Prod is updated.");
+		} else logSuccess("⏭️ EPMS Prod would be updated (dry run).");
+	}
+};
+const epmsAuthenticate = (env) => {
+	if (env === "stage") {
+		if (process.env.EPMS_CLIENT_ID_STAGE && process.env.EPMS_CLIENT_SECRET_STAGE) return EpmsClient.fromClientCredentials(EPMS_API_BASE_URL_STAGE, process.env.EPMS_CLIENT_ID_STAGE, process.env.EPMS_CLIENT_SECRET_STAGE);
+		return EpmsClient.fromBrowserAuth(EPMS_API_BASE_URL_STAGE, EPMS_AUTH_BASE_URL_STAGE, EPMS_AUTH_CLIENT_ID_STAGE);
+	}
+	if (process.env.EPMS_CLIENT_ID && process.env.EPMS_CLIENT_SECRET) return EpmsClient.fromClientCredentials(EPMS_API_BASE_URL_PROD, process.env.EPMS_CLIENT_ID, process.env.EPMS_CLIENT_SECRET);
+	return EpmsClient.fromBrowserAuth(EPMS_API_BASE_URL_PROD, EPMS_AUTH_BASE_URL_PROD, EPMS_AUTH_CLIENT_ID_PROD);
+};
+const loadAccountUuidsFromConfig = (paths) => {
+	if (!("configYml" in paths)) {
+		halt("Fatal error, this should never happen");
+		throw new Error("Fatal error");
+	}
+	const configContent = yaml.load(readFileSync(paths.configYml, "utf8"));
+	const accountUuidsStage = resolveAccountUuidFromConfig(configContent, "epms_stage");
+	return {
+		accountUuidsProd: resolveAccountUuidFromConfig(configContent, "epms"),
+		accountUuidsStage
+	};
+};
+const loadEnv = (paths) => {
+	const filePath = globSync(paths.appEnv).find((file) => path.basename(file) === ".env");
+	if (!filePath) halt("No \".env\" file found. Are you in the folder of the Tamaro configuration?");
+	config({
+		path: filePath,
+		quiet: true
+	});
+};
+const assertIsNotCore$3 = (ifCore) => {
+	if (ifCore()) halt("You cannot update EPMS in the context of Tamaro Core.");
+};
+//#endregion
 //#region src/commands/deploy.ts
 const deploy = async (options) => {
 	const { ifCore } = getIfCoreFns();
@@ -395,6 +730,8 @@ const deploy = async (options) => {
 			halt(error.stderr);
 		}
 	}
+	if (options.skipEpmsSyncOnlyUseInEmergenciesOrYouWillBeFired) logTitle("⚠️  EPMS sync skipped. You better know what you are doing.");
+	else await updateEpms(options);
 	const demoPage = `https://${AWS_S3_BUCKET_TAMARO}/${configName}/${tag}/index.html`;
 	const entryPoint = `https://${AWS_S3_BUCKET_TAMARO}/${configName}/${tag}/${entryFilename}`;
 	logTitle(`\nBundle for "${configName}" is deployed with tag "${tag}".`);
@@ -543,26 +880,32 @@ const listDeployed = async (options) => {
 	}
 	assertOptionsValid$4(options);
 	awsAuthenticate(options);
-	const flags = prepareFlags$3(options);
-	const { config } = options;
+	const { config, profile } = options;
 	const { ifCore } = getIfCoreFns();
 	const configName = config ?? ifCore("tamaro-core", getWidgetUuid());
-	const title = !config && ifCore() ? `Listing deployments of Tamaro Core …` : `Listing deployments of "${configName}" customer configuration …`;
-	const cmd = `aws s3 ls ${`s3://${AWS_S3_BUCKET_TAMARO}/${configName}/`} ${flags}`;
-	let out = "";
-	logTitle(title);
-	logCommand(cmd);
-	try {
-		out = runCommandSync(cmd).stdout;
-	} catch (error) {
-		out = error.stdout;
-		if (error.stderr) halt(error.stderr);
+	logTitle(!config && ifCore() ? `Listing deployments of Tamaro Core …` : `Listing deployments of "${configName}" customer configuration …`);
+	if (profile) process.env.AWS_PROFILE = profile;
+	const deployments = await getConfigDeployments(configName);
+	if (deployments.length === 0) {
+		console.log("\nNo deployments found.\n");
+		return;
 	}
-	const tags = parseTags(out.split("\n"));
-	const text = tags.length === 0 ? "No deployments found." : tags.map((tag, idx) => {
-		return `${idx + 1}. https://${AWS_S3_BUCKET_TAMARO}/${configName}/${tag}/index.html`;
-	}).join("\n");
-	console.log(`${text}\n`);
+	const table = columnify(deployments.map((deployment, idx) => ({
+		"#": `${idx + 1}`,
+		"Deployed At": deployment.date,
+		Tag: deployment.tag,
+		Preview: createTerminalLink("🔍 Live Preview", deployment.fullUrl)
+	})), {
+		columnSplitter: "  |  ",
+		config: {
+			"#": { minWidth: 2 },
+			"Deployed At": { minWidth: 20 },
+			Preview: { minWidth: 16 },
+			Tag: { minWidth: 14 }
+		},
+		minWidth: 10
+	});
+	console.log(`\n${table}\n`);
 };
 const assertOptionsValid$4 = (options) => {
 	const { config, profile } = options;
@@ -574,10 +917,6 @@ const assertConfigValid = (config) => {
 	const regex = /^[\w-]+$/;
 	if (!regex.test(config)) halt(`Flag "--config" has forbidden format. Allowed format: ${regex.toString()}.`);
 };
-const parseTags = (lines) => {
-	const regex = /^\s*PRE\s*/;
-	return lines.filter((line) => regex.test(line)).map((line) => line.replace(regex, "").replace(/\/$/, ""));
-};
 //#endregion
 //#region src/commands/serve.ts
 const serve = async (options) => {
@@ -669,7 +1008,7 @@ const undeploy = async (options) => {
 	const deployUrl = all ? `s3://${AWS_S3_BUCKET_TAMARO}/${configName}/` : `s3://${AWS_S3_BUCKET_TAMARO}/${configName}/${tag}/`;
 	const description = all ? `all tags of "${configName}"` : `tag "${tag}" of "${configName}"`;
 	if (dryRunFlag) logTitle("🧪 DRY RUN MODE - No actual changes will be made 🧪");
-	await promptConfirmation(`Are you sure you want to undeploy ${description}?`, options.yes);
+	await promptConfirmation(`Are you sure you want to undeploy ${description}?`, options.ci);
 	const cmd = `
     aws s3 rm ${deployUrl}
       --recursive
@@ -789,7 +1128,7 @@ const promptBucketTamaroEmailConfig = async () => {
 //#endregion
 //#region package.json
 var name = "@raisenow/tamaro-cli";
-var version = "1.8.0";
+var version = "1.9.0-dev.1";
 //#endregion
 //#region src/cli.ts
 /**
@@ -807,7 +1146,7 @@ const cli = createCommand().name(name).version(version, "-v, --version");
 cli.command("dev").description("Run the local development server for Tamaro Core or a particular customer configuration").option("--local-core", "Load Tamaro Core from localhost:1234 instead of the CDN", false).option("--https", "Let local web server serve Tamaro with SSL encryption", false).option("--port <port>", "Web server port", `${DEFAULT_PORT}`).option("--env <env>", "Environment (dev, stage, prod)").option("--nolint", "Disable ESLint", false).option("--debug", "Enable debug mode", false).action(async (options) => {
 	await dev(options);
 });
-cli.command("build").description("Build an optimised (minified) bundle of Tamaro Core or a customer configuration").option("--local-core", "Load Tamaro Core from localhost:1234 instead of the CDN", false).option("--analyze", "Generate bundle statistics to \"reports\" folder", false).option("--serve", "Run the generated bundle with a local web server", false).option("--https", "Let local web server serve Tamaro with SSL encryption", false).option("--port <port>", "Web server port", `${DEFAULT_PORT}`).option("--env <env>", "Environment (dev, stage, prod)").option("--profile <profile>", "AWS profile").option("--ci", "CI environment", false).option("--deploy", "Deploy Tamaro Core or a customer configuration bundle to AWS S3", false).option("--tag <tag>", "Tag which should be used for the deployment of the bundle", DEFAULT_TAG).option("--nolint", "Disable ESLint", false).option("--debug", "Enable debug mode", false).action(async (options) => {
+cli.command("build").description("Build an optimised (minified) bundle of Tamaro Core or a customer configuration").option("--local-core", "Load Tamaro Core from localhost:1234 instead of the CDN", false).option("--analyze", "Generate bundle statistics to \"reports\" folder", false).option("--serve", "Run the generated bundle with a local web server", false).option("--https", "Let local web server serve Tamaro with SSL encryption", false).option("--port <port>", "Web server port", `${DEFAULT_PORT}`).option("--env <env>", "Environment (dev, stage, prod)").option("--profile <profile>", "AWS profile").option("--ci", "CI environment", false).option("--deploy", "Deploy Tamaro Core or a customer configuration bundle to AWS S3", false).option("--skip-epms-sync-only-use-in-emergencies-or-you-will-be-fired", "Skip the EPMS sync entirely. Only use this in emergencies.", false).option("--tag <tag>", "Tag which should be used for the deployment of the bundle", DEFAULT_TAG).option("--nolint", "Disable ESLint", false).option("--debug", "Enable debug mode", false).action(async (options) => {
 	await build(options);
 	if (options.serve) await serve(options);
 	if (options.deploy) await deploy(options);
@@ -815,7 +1154,7 @@ cli.command("build").description("Build an optimised (minified) bundle of Tamaro
 cli.command("serve").description("Run a local web server for pre-built bundle").option("--port <port>", "Web server port", `${DEFAULT_PORT}`).option("--https", "Let local web server serve Tamaro with SSL encryption", false).action(async (options) => {
 	await serve(options);
 });
-cli.command("deploy").description("Deploy a pre-built Tamaro Core or customer configuration bundle to AWS S3").option("--profile <profile>", "AWS profile").option("--ci", "CI environment", false).option("--tag <tag>", "Tag which should be used for the deployment of the bundle", DEFAULT_TAG).option("--dryrun", "Displays the operations that would be performed without actually running them", false).action(async (options) => {
+cli.command("deploy").description("Deploy a pre-built Tamaro Core or customer configuration bundle to AWS S3").option("--profile <profile>", "AWS profile").option("--ci", "CI environment", false).option("--tag <tag>", "Tag which should be used for the deployment of the bundle", DEFAULT_TAG).option("--dryrun", "Displays the operations that would be performed without actually running them", false).option("--skip-epms-sync-only-use-in-emergencies-or-you-will-be-fired", "Skip the EPMS sync entirely. Only use this in emergencies.", false).action(async (options) => {
 	await deploy(options);
 });
 cli.command("list-deployed").description("List deployments of Tamaro Core or a particular customer configuration").option("--profile <profile>", "AWS profile").option("--ci", "CI environment", false).option("--config <config>", "Configuration name (default: current customer configuration)").action(async (options) => {
@@ -836,6 +1175,9 @@ cli.command("archive").description("Archive a customer configuration by moving i
 cli.command("unarchive").description("Unarchive a customer configuration by restoring it from the _archived folder").option("--profile <profile>", "AWS profile").option("--ci", "CI environment", false).option("--dryrun", "Displays the operations that would be performed without actually running them", false).action((options) => {
 	unarchive(options);
 });
+cli.command("update-epms").description("Update EPMS with the currently deployed widget tags.").option("--profile <profile>", "AWS profile").option("--ci", "CI environment", false).option("--dryrun", "Displays the operations that would be performed without actually running them", false).option("--tag <tag>", "Tag which should be set for the deployment", DEFAULT_TAG).action(async (options) => {
+	await updateEpms(options);
+});
 cli.command("validate").description("Validate the current Tamaro configuration to avoid common errors").action(async () => {
 	await validate();
 });

package/dist/{env-CSg7BrvF.js → env-JzPIlctP.js}

@@ -6,8 +6,10 @@ import prompts from "prompts";
 import stripIndent from "strip-indent";
 import chalk from "chalk";
 import columnify from "columnify";
+import envPaths from "env-paths";
 import { fileURLToPath } from "node:url";
 import { getIfUtils } from "webpack-config-utils";
+import { z } from "zod";
 import { globSync } from "glob";
 import { config } from "dotenv";
 //#region src/lib/logging.ts
@@ -27,6 +29,9 @@ const logDataTable = (data) => {
 	console.log(columnify(data, { showHeaders: false }));
 	console.log("");
 };
+const createTerminalLink = (text, url) => {
+	return `\u001B]8;;${url}\u001B\\${text}\u001B]8;;\u001B\\`;
+};
 //#endregion
 //#region src/lib/command.ts
 const halt = (message) => {
@@ -50,6 +55,26 @@ const promptConfirmation = async (message, skipConfirmation) => {
 	if (!confirmed) halt("Operation cancelled.");
 };
 //#endregion
+//#region src/lib/constants.ts
+const DEFAULT_TAG = "latest";
+const DEFAULT_PORT = 1234;
+const DEFAULT_HTTP_TIMEOUT = 1e4;
+const AWS_S3_BUCKET_TAMARO = "tamaro.raisenow.com";
+const AWS_S3_BUCKET_TAMARO_EMAIL_CONFIG_STAGE = "rnw-stage-email-service";
+const AWS_S3_BUCKET_TAMARO_EMAIL_CONFIG_PROD = "rnw-email-service";
+const EPMS_API_BASE_URL_STAGE = "https://api.stage.mesos.raisenow.net";
+const EPMS_API_BASE_URL_PROD = "https://api.raisenow.io";
+const EPMS_AUTH_BASE_URL_STAGE = "https://login.stage.mesos.raisenow.net";
+const EPMS_AUTH_BASE_URL_PROD = "https://login.raisenow.com";
+const EPMS_AUTH_CLIENT_ID_STAGE = "luna-stage-local";
+const EPMS_AUTH_CLIENT_ID_PROD = "luna-local";
+const CORE_CONFIG_NAME = "tamaro-core";
+const AUTH_PORT = 8080;
+const AWS_CLOUDFRONT_DISTRIBUTION_ID = "EHJ1OM458YQ0I";
+const HTTPS_CRT_FILE = "localhost.crt";
+const HTTPS_KEY_FILE = "localhost.key";
+const CACHE_DIR = envPaths("tamaro-cli", { suffix: "" }).cache;
+//#endregion
 //#region node_modules/.pnpm/tsdown@0.21.8_synckit@0.11.11_typescript@6.0.2/node_modules/tsdown/esm-shims.js
 const getFilename = () => fileURLToPath(import.meta.url);
 const getDirname = () => path.dirname(getFilename());
@@ -145,6 +170,7 @@ const getPaths = (ifCore) => {
 		appTsConfig: resolveApp("tsconfig.json"),
 		appHtml: resolveApp("*.html"),
 		appEnv: resolveApp(".env*"),
+		configYml: resolveApp("config.yml"),
 		appTailwindConfig: void 0
 	});
 };
@@ -171,17 +197,37 @@ const getIfCoreFns = ({ allowArchived = false } = {}) => {
     `));
 	process.exit(1);
 };
-//#endregion
-//#region src/lib/constants.ts
-const DEFAULT_TAG = "latest";
-const DEFAULT_PORT = 1234;
-const AWS_S3_BUCKET_TAMARO = "tamaro.raisenow.com";
-const AWS_S3_BUCKET_TAMARO_EMAIL_CONFIG_STAGE = "rnw-stage-email-service";
-const AWS_S3_BUCKET_TAMARO_EMAIL_CONFIG_PROD = "rnw-email-service";
-const CORE_CONFIG_NAME = "tamaro-core";
-const AWS_CLOUDFRONT_DISTRIBUTION_ID = "EHJ1OM458YQ0I";
-const HTTPS_CRT_FILE = "localhost.crt";
-const HTTPS_KEY_FILE = "localhost.key";
+const resolveAccountUuidFromConfig = (rawConfig, field) => {
+	const epmsConfig = z.object({ [field]: z.record(z.string(), z.unknown()) }).safeParse(rawConfig);
+	if (!epmsConfig.success) return [];
+	const configContent = epmsConfig.data[field];
+	const accountUuid = configContent.account_mapping ?? configContent.account_uuid;
+	const accountUuidValidation = z.uuid().safeParse(accountUuid);
+	const accontUuidArrayValidation = z.array(z.uuid()).safeParse(accountUuid);
+	if (!accountUuidValidation.success && !accontUuidArrayValidation.success) halt(stripIndent(`Could not extract EPMS account UUID(s) from config.yml. Please ensure that the "${field}" field is correctly formatted. Expected formats:
+      1. ${field}:
+           account_uuid: <UUID>
+      
+      Alternatively, if the account_uuid is conditional using "if" / "then" / "else" statements, it must be provided using the "account_mapping" format:
+      2. ${field}:
+           account_mapping:
+            - <UUID_1>
+            - <UUID_2>
+            - <UUID_N>
+      `));
+	if (accontUuidArrayValidation.success) return accontUuidArrayValidation.data;
+	if (accountUuidValidation.success) return [accountUuidValidation.data];
+	throw new Error("This should never happen");
+};
+const TAMARO_VERSION_IN_URL_REGEX = /tamaro-core\/(.*)\/index.js/;
+const extractTamaroVersionFromUrl = (url) => {
+	const match = url.match(TAMARO_VERSION_IN_URL_REGEX);
+	if (match) return match[1].toString();
+};
+const resolveCoreVersion = () => {
+	if (process.env.CORE_VERSION) return process.env.CORE_VERSION;
+	if (process.env.CORE_URL) return extractTamaroVersionFromUrl(process.env.CORE_URL);
+};
 //#endregion
 //#region src/lib/env.ts
 const require = createRequire(import.meta.url);
@@ -297,4 +343,4 @@ const applyEnv = (env) => {
 	if (filePath) config({ path: filePath });
 };
 //#endregion
-export { promptConfirmation as C, logError as D, logDataTable as E, logSuccess as O, halt as S, logCommand as T, getWidgetUuid as _, AWS_S3_BUCKET_TAMARO as a, resolveEslintPluginConfig as b, CORE_CONFIG_NAME as c, HTTPS_CRT_FILE as d, HTTPS_KEY_FILE as f, getRelativePaths as g, getPaths as h, AWS_CLOUDFRONT_DISTRIBUTION_ID as i, logTitle as k, DEFAULT_PORT as l, getIfCoreFns as m, assertEnvValid as n, AWS_S3_BUCKET_TAMARO_EMAIL_CONFIG_PROD as o, extensions as p, getEnvVars as r, AWS_S3_BUCKET_TAMARO_EMAIL_CONFIG_STAGE as s, applyEnv as t, DEFAULT_TAG as u, resolveApp as v, runCommandSync as w, resolveOwn as x, resolveBin as y };
+export { EPMS_AUTH_CLIENT_ID_STAGE as A, logSuccess as B, DEFAULT_PORT as C, EPMS_AUTH_BASE_URL_PROD as D, EPMS_API_BASE_URL_STAGE as E, runCommandSync as F, createTerminalLink as I, logCommand as L, HTTPS_KEY_FILE as M, halt as N, EPMS_AUTH_BASE_URL_STAGE as O, promptConfirmation as P, logDataTable as R, DEFAULT_HTTP_TIMEOUT as S, EPMS_API_BASE_URL_PROD as T, logTitle as V, AWS_S3_BUCKET_TAMARO as _, getIfCoreFns as a, CACHE_DIR as b, getWidgetUuid as c, resolveBin as d, resolveCoreVersion as f, AWS_CLOUDFRONT_DISTRIBUTION_ID as g, AUTH_PORT as h, extensions as i, HTTPS_CRT_FILE as j, EPMS_AUTH_CLIENT_ID_PROD as k, resolveAccountUuidFromConfig as l, resolveOwn as m, assertEnvValid as n, getPaths as o, resolveEslintPluginConfig as p, getEnvVars as r, getRelativePaths as s, applyEnv as t, resolveApp as u, AWS_S3_BUCKET_TAMARO_EMAIL_CONFIG_PROD as v, DEFAULT_TAG as w, CORE_CONFIG_NAME as x, AWS_S3_BUCKET_TAMARO_EMAIL_CONFIG_STAGE as y, logError as z };

package/dist/webpack.config.js

@@ -1,4 +1,4 @@
-import { E as logDataTable, b as resolveEslintPluginConfig, d as HTTPS_CRT_FILE, f as HTTPS_KEY_FILE, g as getRelativePaths, h as getPaths, k as logTitle, m as getIfCoreFns, p as extensions, r as getEnvVars, v as resolveApp } from "./env-CSg7BrvF.js";
+import { M as HTTPS_KEY_FILE, R as logDataTable, V as logTitle, a as getIfCoreFns, i as extensions, j as HTTPS_CRT_FILE, o as getPaths, p as resolveEslintPluginConfig, r as getEnvVars, s as getRelativePaths, u as resolveApp } from "./env-JzPIlctP.js";
 import { createRequire } from "node:module";
 import { existsSync } from "node:fs";
 import path from "node:path";