@resolveio/server-lib 22.3.42 → 22.3.44

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

@@ -1,337 +0,0 @@
-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 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 auth = await login();',
-		'	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 resetBrowserState(page);',
-		'		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');
-}