@resolveio/server-lib 22.3.48 → 22.3.50

package/src/util/ai-runner-qa-auth.ts

@@ -0,0 +1,356 @@
+export interface ResolveIORunnerQaAuthBootstrapScriptOptions {
+	defaultUsername?: string;
+	defaultPassword?: string;
+}
+
+export function buildResolveIORunnerQaAuthBootstrapScript(options: ResolveIORunnerQaAuthBootstrapScriptOptions = {}): string {
+	const defaultUsername = options.defaultUsername || 'admin';
+	const defaultPassword = options.defaultPassword || '';
+	return [
+		'#!/usr/bin/env node',
+		"'use strict';",
+		'',
+		'const fs = require("fs");',
+		'const crypto = require("crypto");',
+		'const http = require("http");',
+		'const https = require("https");',
+		'const path = require("path");',
+		'',
+		'const projectRoot = path.resolve(process.argv[2] || process.cwd());',
+		'const routeArg = process.argv[3] || process.env.RESOLVEIO_RUNNER_QA_TARGET_ROUTE || process.env.RESOLVEIO_SUPPORT_QA_TARGET_ROUTE || process.env.RESOLVEIO_SUPPORT_QA_LAST_URL || "/";',
+		'const targetRoute = routeArg.startsWith("/") ? routeArg : `/${routeArg}`;',
+		'const clientUrl = stripTrailingSlash(process.env.RESOLVEIO_RUNNER_QA_CLIENT_URL || process.env.RESOLVEIO_SUPPORT_QA_CLIENT_URL || `http://localhost:${process.env.RESOLVEIO_SUPPORT_QA_CLIENT_PORT || "4200"}`);',
+		'const serverUrl = stripTrailingSlash(process.env.RESOLVEIO_RUNNER_QA_SERVER_URL || process.env.RESOLVEIO_SUPPORT_QA_SERVER_URL || "http://localhost:8080");',
+		`const username = process.env.RESOLVEIO_RUNNER_QA_USERNAME || process.env.RESOLVEIO_SUPPORT_QA_USERNAME || ${JSON.stringify(defaultUsername)};`,
+		`const password = process.env.RESOLVEIO_RUNNER_QA_PASSWORD || process.env.RESOLVEIO_SUPPORT_QA_PASSWORD || ${JSON.stringify(defaultPassword)};`,
+		'const artifactDir = path.resolve(process.env.RESOLVEIO_RUNNER_QA_ARTIFACT_DIR || process.env.RESOLVEIO_SUPPORT_QA_ARTIFACT_DIR || path.join(projectRoot, "qa-artifacts"));',
+		'const viewportWidth = Number(process.env.RESOLVEIO_RUNNER_QA_VIEWPORT_WIDTH || process.env.RESOLVEIO_SUPPORT_QA_VIEWPORT_WIDTH || 1920);',
+		'const viewportHeight = Number(process.env.RESOLVEIO_RUNNER_QA_VIEWPORT_HEIGHT || process.env.RESOLVEIO_SUPPORT_QA_VIEWPORT_HEIGHT || 1080);',
+		'const resultPath = path.join(artifactDir, "auth-bootstrap-result.json");',
+		'const readyScreenshotPath = path.join(artifactDir, "auth-bootstrap-ready.png");',
+		'const failureScreenshotPath = path.join(artifactDir, "auth-bootstrap-failed.png");',
+		'',
+		'function stripTrailingSlash(value) {',
+		'	return String(value || "").replace(/\\/+$/, "");',
+		'}',
+		'',
+		'function isLocalhostUrl(value) {',
+		'	try {',
+		'		const parsed = new URL(value);',
+		'		return ["localhost", "127.0.0.1", "::1"].includes(parsed.hostname);',
+		'	}',
+		'	catch (error) {',
+		'		return false;',
+		'	}',
+		'}',
+		'',
+		'function resolveLocalMongoUrl() {',
+		'	return process.env.MONGO_URL || process.env.RESOLVEIO_RUNNER_QA_MONGO_URL || process.env.RESOLVEIO_SUPPORT_QA_MONGO_URL || `mongodb://127.0.0.1:${process.env.RESOLVEIO_SUPPORT_QA_MONGO_PORT || "3001"}/resolveio?directConnection=true`;',
+		'}',
+		'',
+		'function requireMongoClient() {',
+		'	const candidates = [',
+		'		path.join(projectRoot, "server", "node_modules", "mongodb"),',
+		'		path.join(projectRoot, "node_modules", "mongodb"),',
+		'		path.join(process.cwd(), "server", "node_modules", "mongodb"),',
+		'		path.join(process.cwd(), "node_modules", "mongodb"),',
+		'		"mongodb"',
+		'	];',
+		'	for (const candidate of candidates) {',
+		'		try { return require(candidate).MongoClient; }',
+		'		catch (error) {}',
+		'	}',
+		'	throw new Error("Unable to require mongodb from project/server node_modules or global resolution");',
+		'}',
+		'',
+		'async function ensureLocalQaUser() {',
+		'	if (!isLocalhostUrl(serverUrl) || process.env.RESOLVEIO_RUNNER_QA_DISABLE_LOCAL_USER_REPAIR === "true" || process.env.RESOLVEIO_SUPPORT_QA_DISABLE_LOCAL_USER_REPAIR === "true") {',
+		'		return false;',
+		'	}',
+		'	const MongoClient = requireMongoClient();',
+		'	const client = new MongoClient(resolveLocalMongoUrl());',
+		'	await client.connect();',
+		'	try {',
+		'		const db = client.db();',
+		'		const users = db.collection("users");',
+		'		const now = new Date();',
+		'		const salt = crypto.randomBytes(32).toString("hex");',
+		'		const hash = crypto.pbkdf2Sync(password, salt, 25000, 512, "sha256").toString("hex");',
+		'		const existing = await users.findOne({ $or: [{ username }, { email: username }] }, { projection: { _id: 1 } });',
+		'		const baseUser = {',
+		'			__v: 0,',
+		'			username,',
+		'			email: username.includes("@") ? username : "dev@resolveio.com",',
+		'			fullname: "QA Admin",',
+		'			roles: { super_admin: true, approvals: [], groups: [], notifications: [], miscs: [] },',
+		'			active: true,',
+		'			other: { yards: [] },',
+		'			phonenumber: "",',
+		'			readonly: false,',
+		'			is_customer: false,',
+		'			hash,',
+		'			salt,',
+		'			attempts: 0,',
+		'			services: {},',
+		'			updatedAt: now',
+		'		};',
+		'		if (existing && existing._id) {',
+		'			await users.updateOne({ _id: existing._id }, { $set: baseUser });',
+		'		}',
+		'		else {',
+		'			await users.insertOne({ _id: crypto.randomBytes(12).toString("hex"), createdAt: now, ...baseUser });',
+		'		}',
+		'		return true;',
+		'	}',
+		'	finally {',
+		'		await client.close().catch(() => undefined);',
+		'	}',
+		'}',
+		'',
+		'function writeResult(payload) {',
+		'	fs.mkdirSync(artifactDir, { recursive: true });',
+		'	fs.writeFileSync(resultPath, JSON.stringify(payload, null, 2));',
+		'}',
+		'',
+		'function requestJson(url, payload) {',
+		'	return new Promise((resolve, reject) => {',
+		'		const body = JSON.stringify(payload || {});',
+		'		const parsed = new URL(url);',
+		'		const mod = parsed.protocol === "https:" ? https : http;',
+		'		const req = mod.request(parsed, {',
+		'			method: "POST",',
+		'			timeout: 20000,',
+		'			headers: {',
+		'				"content-type": "application/json",',
+		'				"content-length": Buffer.byteLength(body),',
+		'				"origin": clientUrl',
+		'			}',
+		'		}, (res) => {',
+		'			let raw = "";',
+		'			res.setEncoding("utf8");',
+		'			res.on("data", (chunk) => { raw += chunk; });',
+		'			res.on("end", () => {',
+		'				let json = null;',
+		'				try { json = raw ? JSON.parse(raw) : {}; }',
+		'				catch (error) {',
+		'					reject(new Error(`${url} returned non-JSON HTTP ${res.statusCode}: ${raw.slice(0, 300)}`));',
+		'					return;',
+		'				}',
+		'				if (!res.statusCode || res.statusCode >= 400) {',
+		'					reject(new Error(`${url} returned HTTP ${res.statusCode}: ${JSON.stringify(json).slice(0, 500)}`));',
+		'					return;',
+		'				}',
+		'				resolve(json);',
+		'			});',
+		'		});',
+		'		req.on("timeout", () => req.destroy(new Error(`${url} timed out`)));',
+		'		req.on("error", reject);',
+		'		req.write(body);',
+		'		req.end();',
+		'	});',
+		'}',
+		'',
+		'function requirePuppeteer() {',
+		'	const candidates = [',
+		'		path.join(projectRoot, "server", "node_modules", "puppeteer", "lib", "cjs", "puppeteer", "puppeteer.js"),',
+		'		path.join(projectRoot, "node_modules", "puppeteer", "lib", "cjs", "puppeteer", "puppeteer.js"),',
+		'		path.join(process.cwd(), "server", "node_modules", "puppeteer", "lib", "cjs", "puppeteer", "puppeteer.js"),',
+		'		path.join(process.cwd(), "node_modules", "puppeteer", "lib", "cjs", "puppeteer", "puppeteer.js"),',
+		'		"puppeteer"',
+		'	];',
+		'	for (const candidate of candidates) {',
+		'		try { return require(candidate); }',
+		'		catch (error) {}',
+		'	}',
+		'	throw new Error("Unable to require puppeteer from project/server node_modules or global resolution");',
+		'}',
+		'',
+		'async function login() {',
+		'	if (!password) {',
+		'		throw new Error("QA password is empty; source .resolveio-support-tools/env.sh or set RESOLVEIO_RUNNER_QA_PASSWORD before auth bootstrap");',
+		'	}',
+		'	let loginJson = await requestJson(`${serverUrl}/login`, { username, password });',
+		'	if ((loginJson && loginJson.error) && /Invalid Username And Password|Too Many Attempts/i.test(String(loginJson.result || ""))) {',
+		'		const repaired = await ensureLocalQaUser();',
+		'		if (repaired) {',
+		'			loginJson = await requestJson(`${serverUrl}/login`, { username, password });',
+		'		}',
+		'	}',
+		'	const refreshToken = loginJson && loginJson.result && loginJson.result.token;',
+		'	if (loginJson.error || !refreshToken) {',
+		'		throw new Error(`Login failed: ${JSON.stringify(loginJson).slice(0, 800)}`);',
+		'	}',
+		'	const accessJson = await requestJson(`${serverUrl}/accessToken`, { refreshToken });',
+		'	const accessToken = accessJson && accessJson.result && accessJson.result.token;',
+		'	const user = accessJson && accessJson.result && accessJson.result.user;',
+		'	if (accessJson.error || !accessToken || !user) {',
+		'		throw new Error(`Access token failed: ${JSON.stringify(accessJson).slice(0, 800)}`);',
+		'	}',
+		'	return { refreshToken, accessToken, user };',
+		'}',
+		'',
+		'async function launchBrowser(puppeteer) {',
+		'	const browserUrl = process.env.RESOLVEIO_RUNNER_QA_BROWSER_URL || process.env.RESOLVEIO_SUPPORT_QA_BROWSER_URL || "";',
+		'	if (browserUrl) {',
+		'		return puppeteer.connect({ browserURL: browserUrl, protocolTimeout: 30000, defaultViewport: null });',
+		'	}',
+		'	const launchOptions = {',
+		'		headless: true,',
+		'		defaultViewport: { width: viewportWidth, height: viewportHeight },',
+		'		args: ["--no-sandbox", "--disable-setuid-sandbox", "--disable-dev-shm-usage", `--window-size=${viewportWidth},${viewportHeight}`]',
+		'	};',
+		'	if (process.env.PUPPETEER_EXECUTABLE_PATH || process.env.CHROME_BIN) {',
+		'		launchOptions.executablePath = process.env.PUPPETEER_EXECUTABLE_PATH || process.env.CHROME_BIN;',
+		'	}',
+		'	return puppeteer.launch(launchOptions);',
+		'}',
+		'',
+		'async function resetBrowserState(page) {',
+		'	await page.goto(clientUrl, { waitUntil: "domcontentloaded", timeout: 45000 });',
+		'	await page.evaluate(async () => {',
+		'		try {',
+		'			const registrations = await navigator.serviceWorker.getRegistrations();',
+		'			await Promise.all(registrations.map((registration) => registration.unregister().catch(() => false)));',
+		'		} catch (error) {}',
+		'		try {',
+		'			if (window.caches && window.caches.keys) {',
+		'				const keys = await window.caches.keys();',
+		'				await Promise.all(keys.map((key) => window.caches.delete(key).catch(() => false)));',
+		'			}',
+		'		} catch (error) {}',
+		'		try {',
+		'			if (window.indexedDB && window.indexedDB.databases) {',
+		'				const databases = await window.indexedDB.databases();',
+		'				await Promise.all(databases.filter((database) => database && database.name).map((database) => new Promise((resolve) => {',
+		'					const request = window.indexedDB.deleteDatabase(database.name);',
+		'					request.onsuccess = () => resolve(true);',
+		'					request.onerror = () => resolve(false);',
+		'					request.onblocked = () => resolve(false);',
+		'				})));',
+		'			}',
+		'		} catch (error) {}',
+		'		localStorage.clear();',
+		'		sessionStorage.clear();',
+		'	});',
+		'}',
+		'',
+		'async function seedAuth(page, auth) {',
+		'	await page.evaluate((payload) => {',
+		'		localStorage.setItem("refreshToken", payload.refreshToken);',
+		'		localStorage.setItem("accessToken", payload.accessToken);',
+		'		localStorage.setItem("user", JSON.stringify(payload.user));',
+		'		localStorage.setItem("lastURL", payload.lastURL);',
+		'		localStorage.setItem("resolveio.runnerQaAuthBootstrappedAt", payload.bootstrappedAt);',
+		'	}, { ...auth, lastURL: targetRoute, bootstrappedAt: new Date().toISOString() });',
+		'}',
+		'',
+		'function delay(ms) {',
+		'	return new Promise((resolve) => setTimeout(resolve, ms));',
+		'}',
+		'',
+		'async function logoutExistingBrowserSession(page) {',
+		'	try {',
+		'		await page.goto(clientUrl, { waitUntil: "domcontentloaded", timeout: 45000 });',
+		'		await delay(500);',
+		'		await page.evaluate(() => {',
+		'			const controls = Array.from(document.querySelectorAll("button, a, [role=\'button\']"));',
+		'			const logoutControl = controls.find((control) => /(^|\\s)logout(\\s|$)/i.test((control.textContent || "").trim()));',
+		'			if (logoutControl && typeof logoutControl.click === "function") {',
+		'				logoutControl.click();',
+		'				return true;',
+		'			}',
+		'			return false;',
+		'		});',
+		'		await delay(1000);',
+		'	}',
+		'	catch (error) {}',
+		'}',
+		'',
+		'async function waitForAuthenticatedApp(page) {',
+		'	const url = `${clientUrl}${targetRoute}`;',
+		'	await page.goto(url, { waitUntil: "domcontentloaded", timeout: 60000 });',
+		'	await page.waitForFunction(() => {',
+		'		const text = (document.body && document.body.innerText || "").replace(/\\s+/g, " ").trim();',
+		'		const hasTokens = !!localStorage.getItem("refreshToken") && !!localStorage.getItem("accessToken") && !!localStorage.getItem("user");',
+		'		const hasLogin = /Employee\\/Customer Login|Employee Sign In|Customer Access|Unable to sign in/i.test(text);',
+		'		const hasOffline = text.includes("*** OFFLINE MODE ***");',
+		'		return hasTokens && !hasLogin && !hasOffline && text.length > 40;',
+		'	}, { timeout: Number(process.env.RESOLVEIO_RUNNER_QA_AUTH_TIMEOUT_MS || process.env.RESOLVEIO_SUPPORT_QA_AUTH_TIMEOUT_MS || 60000) });',
+		'	await delay(1000);',
+		'}',
+		'',
+		'async function pageSummary(page) {',
+		'	return page.evaluate(() => {',
+		'		const bodyText = (document.body && document.body.innerText || "").replace(/\\s+/g, " ").trim();',
+		'		return {',
+		'			url: location.href,',
+		'			title: document.title,',
+		'			hasAngularDebug: !!window.ng,',
+		'			hasRefreshToken: !!localStorage.getItem("refreshToken"),',
+		'			hasAccessToken: !!localStorage.getItem("accessToken"),',
+		'			hasUser: !!localStorage.getItem("user"),',
+		'			hasOfflineModeText: bodyText.includes("*** OFFLINE MODE ***"),',
+		'			hasLoginText: /Employee\\/Customer Login|Employee Sign In|Customer Access|Unable to sign in/i.test(bodyText),',
+		'			bodyTextSnippet: bodyText.slice(0, 800),',
+		'			localStorageKeys: Object.keys(localStorage).sort()',
+		'		};',
+		'	});',
+		'}',
+		'',
+		'(async () => {',
+		'	fs.mkdirSync(artifactDir, { recursive: true });',
+		'	const puppeteer = requirePuppeteer();',
+		'	const browser = await launchBrowser(puppeteer);',
+		'	let page;',
+		'	try {',
+		'		page = await browser.newPage();',
+		'		await page.setViewport({ width: viewportWidth, height: viewportHeight });',
+		'		page.on("console", (msg) => {',
+		'			const text = msg.text();',
+		'			if (["error", "warning"].includes(msg.type()) || /error/i.test(text)) {',
+		'				console.log("[browser console]", msg.type(), text);',
+		'			}',
+		'		});',
+		'		page.on("pageerror", (error) => console.log("[pageerror]", error.message));',
+		'		await logoutExistingBrowserSession(page);',
+		'		await resetBrowserState(page);',
+		'		const auth = await login();',
+		'		await seedAuth(page, auth);',
+		'		await waitForAuthenticatedApp(page);',
+		'		await page.screenshot({ path: readyScreenshotPath, fullPage: true });',
+		'		const summary = {',
+		'			status: "pass",',
+		'			clientUrl,',
+		'			serverUrl,',
+		'			targetRoute,',
+		'			screenshot: readyScreenshotPath,',
+		'			user: { _id: auth.user && auth.user._id, username: auth.user && auth.user.username, fullname: auth.user && auth.user.fullname },',
+		'			page: await pageSummary(page)',
+		'		};',
+		'		writeResult(summary);',
+		'		console.log(JSON.stringify(summary, null, 2));',
+		'	}',
+		'	catch (error) {',
+		'		let summary = { status: "fail", clientUrl, serverUrl, targetRoute, screenshot: failureScreenshotPath, error: error && error.stack || String(error) };',
+		'		try {',
+		'			if (page) {',
+		'				await page.screenshot({ path: failureScreenshotPath, fullPage: true });',
+		'				summary.page = await pageSummary(page);',
+		'			}',
+		'		} catch (screenshotError) {',
+		'			summary.screenshotError = screenshotError && screenshotError.stack || String(screenshotError);',
+		'		}',
+		'		writeResult(summary);',
+		'		console.error(JSON.stringify(summary, null, 2));',
+		'		process.exitCode = 1;',
+		'	}',
+		'	finally {',
+		'		if (browser && typeof browser.close === "function") {',
+		'			await browser.close().catch(() => undefined);',
+		'		}',
+		'		process.exit(process.exitCode || 0);',
+		'	}',
+		'})();',
+		''
+	].join('\n');
+}