@rollupdate/hctl 0.0.0-stage → 3.0.0

package/dist/cloud/browser-bootstrap.js

@@ -0,0 +1,438 @@
+import { chmodSync, existsSync, mkdirSync, readFileSync, writeFileSync, } from "node:fs";
+import { dirname, resolve } from "node:path";
+import { confirm, input, password } from "@inquirer/prompts";
+import { Launcher } from "chrome-launcher";
+import { connect } from "puppeteer-real-browser";
+import { createContext, validateCloudToken } from "./context.js";
+import { HETZNER_CLOUD_CONSOLE_URL } from "./token-instructions.js";
+const ENV_TOKEN_KEY = "HETZNER_CLOUD_TOKEN";
+const TRAILING_NEWLINES_REGEX = /\n+$/;
+const PROJECT_CARD_SELECTOR = '[data-test="project"]';
+const SECURITY_LINK_SELECTOR = '[data-test="main-nav__link--security"]';
+const API_TOKENS_LINK_SELECTOR = 'a[href$="/security/tokens"]';
+const DIALOG_INPUT_SELECTOR = 'input[data-test="input"]';
+const READ_PERMISSION_SELECTOR = '[data-test="radio-item--read"]';
+const READ_WRITE_PERMISSION_SELECTOR = '[data-test="radio-item--read_write"]';
+const SELECT_ALL_MODIFIER = process.platform === "darwin" ? "Meta" : "Control";
+const DISABLE_FEATURES_FLAG = "--disable-features=";
+function sandboxedChromeFlags() {
+    const flags = Launcher.defaultFlags()
+        .filter((flag) => flag !== "--disable-component-update")
+        .filter((flag) => !flag.includes("no-sandbox"));
+    return flags.map((flag) => flag.startsWith(DISABLE_FEATURES_FLAG)
+        ? `${flag},AutomationControlled`
+        : flag);
+}
+function resolveEnvFilePath(envFile) {
+    if (typeof envFile === "string") {
+        return resolve(envFile);
+    }
+    return resolve(process.cwd(), ".env");
+}
+export function normalizePermission(value) {
+    if (value === "read" || value === "read-write") {
+        return value;
+    }
+    throw new Error("Permission must be 'read' or 'read-write'.");
+}
+export function upsertEnvValue(content, key, value) {
+    const normalizedContent = content.replace(TRAILING_NEWLINES_REGEX, "");
+    const lines = normalizedContent.length > 0 ? normalizedContent.split("\n") : [];
+    const nextLine = `${key}=${value}`;
+    let found = false;
+    const updatedLines = lines.map((line) => {
+        if (line.startsWith(`${key}=`)) {
+            found = true;
+            return nextLine;
+        }
+        return line;
+    });
+    if (!found) {
+        updatedLines.push(nextLine);
+    }
+    return `${updatedLines.join("\n").replace(TRAILING_NEWLINES_REGEX, "")}\n`;
+}
+export function writeEnvToken(envFile, token) {
+    const currentContent = existsSync(envFile)
+        ? readFileSync(envFile, "utf-8")
+        : "";
+    const nextContent = upsertEnvValue(currentContent, ENV_TOKEN_KEY, token);
+    mkdirSync(dirname(envFile), { recursive: true });
+    writeFileSync(envFile, nextContent, { mode: 0o600 });
+    chmodSync(envFile, 0o600);
+}
+export function browserConnectionOptions() {
+    return {
+        args: [
+            ...sandboxedChromeFlags(),
+            "--start-maximized",
+            "--disable-dev-shm-usage",
+        ],
+        connectOption: {
+            defaultViewport: null,
+        },
+        headless: false,
+        // puppeteer-real-browser otherwise injects --no-sandbox.
+        ignoreAllFlags: true,
+        turnstile: true,
+    };
+}
+async function delay(ms) {
+    await new Promise((resolveDelay) => setTimeout(resolveDelay, ms));
+}
+async function clickVisibleText(page, labels) {
+    const point = await page.evaluate((candidateLabels) => {
+        const normalizedLabels = candidateLabels.map((label) => label.toLowerCase().trim());
+        const isVisible = (element) => {
+            const htmlElement = element;
+            const rect = htmlElement.getBoundingClientRect();
+            const style = window.getComputedStyle(htmlElement);
+            return (rect.width > 0 &&
+                rect.height > 0 &&
+                style.display !== "none" &&
+                style.visibility !== "hidden" &&
+                style.opacity !== "0");
+        };
+        const getTexts = (element) => [
+            element.textContent ?? "",
+            element.getAttribute("aria-label") ?? "",
+            element.getAttribute("title") ?? "",
+            element.getAttribute("value") ?? "",
+        ]
+            .map((value) => value.toLowerCase().replace(/\s+/g, " ").trim())
+            .filter((value) => value.length > 0);
+        const elements = Array.from(document.querySelectorAll("button,a,[role='button'],[role='radio'],input[type='button'],input[type='submit']"));
+        const matches = elements.filter((element) => {
+            const elementTexts = getTexts(element);
+            return (isVisible(element) &&
+                normalizedLabels.some((label) => elementTexts.includes(label)));
+        });
+        const match = matches.at(-1);
+        if (!match) {
+            return null;
+        }
+        const rect = match.getBoundingClientRect();
+        return { x: rect.left + rect.width / 2, y: rect.top + rect.height / 2 };
+    }, labels);
+    if (!point) {
+        return false;
+    }
+    await page.mouse.click(point.x, point.y);
+    return true;
+}
+async function clickVisibleSelector(page, selector) {
+    try {
+        const element = await page.waitForSelector(selector, {
+            timeout: 15_000,
+            visible: true,
+        });
+        if (!element) {
+            return false;
+        }
+        await element.click();
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+async function fillVisibleInput(page, value, labels = []) {
+    for (let attempt = 0; attempt < 10; attempt += 1) {
+        const filled = await page.evaluate(({ candidateLabels }) => {
+            const normalizedLabels = candidateLabels.map((label) => label.toLowerCase().trim());
+            const isVisible = (element) => {
+                const htmlElement = element;
+                const rect = htmlElement.getBoundingClientRect();
+                const style = window.getComputedStyle(htmlElement);
+                return (rect.width > 0 &&
+                    rect.height > 0 &&
+                    style.display !== "none" &&
+                    style.visibility !== "hidden" &&
+                    style.opacity !== "0");
+            };
+            const getInputText = (inputElement) => [
+                inputElement.name,
+                inputElement.id,
+                inputElement.placeholder,
+                inputElement.getAttribute("aria-label") ?? "",
+                Array.from(inputElement.labels ?? [])
+                    .map((label) => label.textContent ?? "")
+                    .join(" "),
+            ]
+                .join(" ")
+                .toLowerCase();
+            const inputs = Array.from(document.querySelectorAll("input:not([type='hidden']):not([disabled]),textarea:not([disabled])")).filter(isVisible);
+            const matchedInput = [...inputs]
+                .reverse()
+                .find((inputElement) => normalizedLabels.some((label) => getInputText(inputElement).includes(label))) ?? inputs.at(-1);
+            if (!matchedInput) {
+                return null;
+            }
+            const rect = matchedInput.getBoundingClientRect();
+            return { x: rect.left + rect.width / 2, y: rect.top + rect.height / 2 };
+        }, { candidateLabels: labels });
+        if (filled) {
+            await page.mouse.click(filled.x, filled.y);
+            await page.keyboard.down(SELECT_ALL_MODIFIER);
+            await page.keyboard.press("A");
+            await page.keyboard.up(SELECT_ALL_MODIFIER);
+            await page.keyboard.type(value);
+            await page.keyboard.press("Tab");
+            return true;
+        }
+        await delay(500);
+    }
+    return false;
+}
+async function clickTopRightOverlayControl(page) {
+    const point = await page.evaluate(() => {
+        const isVisible = (element) => {
+            const htmlElement = element;
+            const rect = htmlElement.getBoundingClientRect();
+            const style = window.getComputedStyle(htmlElement);
+            return (rect.width > 0 &&
+                rect.height > 0 &&
+                style.display !== "none" &&
+                style.visibility !== "hidden" &&
+                style.opacity !== "0");
+        };
+        const overlays = Array.from(document.querySelectorAll("[role='dialog'],.modal,.dialog")).filter(isVisible);
+        const overlay = overlays.find((element) => (element.textContent ?? "").toLowerCase().includes("what's new")) ?? overlays.at(-1);
+        if (!overlay) {
+            return null;
+        }
+        const overlayRect = overlay.getBoundingClientRect();
+        const controls = Array.from(overlay.querySelectorAll("button,[role='button'],a,svg,[aria-label]")).filter(isVisible);
+        const candidates = controls
+            .map((control) => {
+            const rect = control.getBoundingClientRect();
+            return {
+                score: rect.left + (overlayRect.bottom - rect.top),
+                x: rect.left + rect.width / 2,
+                y: rect.top + rect.height / 2,
+            };
+        })
+            .sort((left, right) => right.score - left.score);
+        return candidates[0] ? { x: candidates[0].x, y: candidates[0].y } : null;
+    });
+    if (!point) {
+        return false;
+    }
+    await page.mouse.click(point.x, point.y);
+    return true;
+}
+async function closeConsoleOverlays(page) {
+    await page.keyboard.press("Escape");
+    await delay(500);
+    if (!(await clickVisibleText(page, ["close", "dismiss", "×"]))) {
+        await clickTopRightOverlayControl(page);
+    }
+    await delay(500);
+}
+async function clickProjectCard(page, projectName) {
+    const point = await page.evaluate(({ name, selector }) => {
+        const normalizedName = name.toLowerCase().trim();
+        const cards = Array.from(document.querySelectorAll(selector));
+        const match = cards.find((card) => {
+            const rect = card.getBoundingClientRect();
+            const style = window.getComputedStyle(card);
+            const text = (card.textContent ?? "")
+                .toLowerCase()
+                .replace(/\s+/g, " ")
+                .trim();
+            return (rect.width > 0 &&
+                rect.height > 0 &&
+                style.visibility !== "hidden" &&
+                text.includes(normalizedName));
+        });
+        if (!match) {
+            return null;
+        }
+        const rect = match.getBoundingClientRect();
+        return { x: rect.left + rect.width / 2, y: rect.top + rect.height / 2 };
+    }, { name: projectName, selector: PROJECT_CARD_SELECTOR });
+    if (!point) {
+        return false;
+    }
+    await page.mouse.click(point.x, point.y);
+    return true;
+}
+async function createProject(page, projectName) {
+    const clickedNewProject = await clickVisibleText(page, [
+        "new project",
+        "+ new project",
+    ]);
+    if (!clickedNewProject) {
+        throw new Error("Could not find the New project control.");
+    }
+    await delay(1000);
+    const filledName = await fillVisibleInput(page, projectName, [
+        "project",
+        "name",
+    ]);
+    if (!filledName) {
+        throw new Error("Could not find the project name field.");
+    }
+    const clickedCreate = await clickVisibleText(page, ["add project"]);
+    if (!clickedCreate) {
+        throw new Error("Could not find the Create project button.");
+    }
+    await delay(3000);
+}
+async function ensureProjectOpen(page, projectName, createIfMissing) {
+    await page.goto(`${HETZNER_CLOUD_CONSOLE_URL}/projects`, {
+        waitUntil: "domcontentloaded",
+    });
+    await delay(2000);
+    await closeConsoleOverlays(page);
+    if (await clickProjectCard(page, projectName)) {
+        await delay(2500);
+        return;
+    }
+    if (!createIfMissing) {
+        throw new Error(`Could not find project '${projectName}'. Rerun with --create-project to create it.`);
+    }
+    await createProject(page, projectName);
+    await closeConsoleOverlays(page);
+    if (await clickProjectCard(page, projectName)) {
+        await delay(2500);
+        return;
+    }
+    throw new Error(`Created project '${projectName}' but could not open it.`);
+}
+async function openApiTokenForm(page, tokenName, permission) {
+    await closeConsoleOverlays(page);
+    const clickedSecurity = await clickVisibleSelector(page, SECURITY_LINK_SELECTOR);
+    if (!clickedSecurity) {
+        throw new Error("Could not find the Security section.");
+    }
+    await delay(1500);
+    const clickedApiTokens = await clickVisibleSelector(page, API_TOKENS_LINK_SELECTOR);
+    if (!clickedApiTokens) {
+        throw new Error("Could not find the API Tokens section.");
+    }
+    await delay(1500);
+    const clickedGenerate = await clickVisibleText(page, [
+        "generate api token",
+        "generate",
+    ]);
+    if (!clickedGenerate) {
+        throw new Error("Could not find the Generate API Token button.");
+    }
+    await delay(1000);
+    const inputReady = await page
+        .waitForSelector(DIALOG_INPUT_SELECTOR, { timeout: 15_000, visible: true })
+        .then(Boolean)
+        .catch(() => false);
+    const filledTokenName = inputReady &&
+        (await fillVisibleInput(page, tokenName, ["description", "name"]));
+    if (!filledTokenName) {
+        throw new Error("Could not find the API token name field.");
+    }
+    const permissionClicked = await clickVisibleSelector(page, permission === "read-write"
+        ? READ_WRITE_PERMISSION_SELECTOR
+        : READ_PERMISSION_SELECTOR);
+    if (!permissionClicked) {
+        throw new Error(`Could not select ${permission} token permissions.`);
+    }
+}
+async function submitApiTokenForm(page) {
+    const clickedFinalGenerate = await clickVisibleText(page, [
+        "generate api token",
+    ]);
+    if (!clickedFinalGenerate) {
+        throw new Error("Could not find the final Generate token button.");
+    }
+    await delay(1500);
+}
+async function automateTokenSetup(page, options, tokenName) {
+    await ensureProjectOpen(page, options.projectName, options.createProject === true);
+    await openApiTokenForm(page, tokenName, options.permission);
+}
+async function openConsole(projectName) {
+    const { browser, page } = await connect(browserConnectionOptions());
+    await page.goto(HETZNER_CLOUD_CONSOLE_URL, { waitUntil: "domcontentloaded" });
+    console.log("");
+    console.log("A local real-browser session is open.");
+    console.log("Use the browser to log in to Hetzner Cloud, including 2FA.");
+    console.log(`After login, hctl will prepare project '${projectName}'.`);
+    console.log("");
+    console.log("Leave the browser open until you have copied the generated token.");
+    return { browser, page };
+}
+export async function runCloudTokenBootstrap(options) {
+    const tokenName = options.tokenName ?? `hctl-${options.projectName.toLowerCase()}`;
+    const permissionLabel = options.permission === "read-write" ? "Read & Write" : "Read";
+    console.log("");
+    console.log("Assisted Hetzner Cloud API Token Bootstrap");
+    console.log("");
+    console.log("This opens a visible local real-browser session.");
+    console.log("hctl does not ask for or store your Hetzner console password.");
+    console.log("hctl does not scrape the one-time token from the page.");
+    console.log("After Hetzner shows the token, copy it yourself and paste it into the hidden prompt.");
+    console.log("");
+    console.log(`Project: ${options.projectName}`);
+    console.log(`Create project if missing: ${options.createProject ? "yes" : "no"}`);
+    console.log(`Token name: ${tokenName}`);
+    console.log(`Token permission: ${permissionLabel}`);
+    console.log(`Context to save: ${options.contextName}`);
+    if (options.envFile) {
+        console.log(`Also write ${ENV_TOKEN_KEY} to: ${resolveEnvFilePath(options.envFile)}`);
+    }
+    console.log("");
+    const proceed = await confirm({
+        default: false,
+        message: "Open the Hetzner Cloud Console in a local real-browser session and continue?",
+    });
+    if (!proceed) {
+        console.log("Aborted.");
+        return false;
+    }
+    const { browser, page } = await openConsole(options.projectName);
+    try {
+        await input({
+            message: "After logging in to Hetzner Cloud in the browser, press Enter to automate project/token setup.",
+        });
+        console.log("Automating Hetzner Console setup...");
+        await automateTokenSetup(page, options, tokenName);
+        console.log("");
+        console.log("The API token form should now be ready in the browser.");
+        console.log(`  - Token name: ${tokenName}`);
+        console.log(`  - Permission: ${permissionLabel}`);
+        console.log("");
+        const generateToken = await confirm({
+            default: false,
+            message: `Generate the '${tokenName}' ${permissionLabel} API token now?`,
+        });
+        if (!generateToken) {
+            console.log("Aborted before token generation.");
+            return false;
+        }
+        await submitApiTokenForm(page);
+        console.log("The token was generated. Copy it now; Hetzner shows it only once.");
+        console.log("");
+        const tokenCopied = await confirm({
+            default: false,
+            message: "Have you copied the generated Hetzner Cloud API token?",
+        });
+        if (!tokenCopied) {
+            console.log("Aborted.");
+            return false;
+        }
+        const token = await password({
+            message: "Paste the generated Hetzner Cloud API token:",
+            validate: (value) => value.trim().length > 0 || "Token is required",
+        });
+        if (options.verify !== false) {
+            await validateCloudToken(token);
+        }
+        await createContext(options.contextName, token, { verify: false });
+        if (options.envFile) {
+            writeEnvToken(resolveEnvFilePath(options.envFile), token);
+        }
+        return true;
+    }
+    finally {
+        await browser.close();
+    }
+}