@bigbinary/neeto-playwright-commons 3.0.8 → 3.1.1

package/README.md

@@ -132,6 +132,7 @@ import { COMMON_SELECTORS } from "@bigbinary/neeto-playwright-common";
 - [MailerUtils](./docs/utils/mailer-utils.md)
 - [EmailDeliveryUtils](./docs/utils/email-delivery-utils.md)
 - [NeetoAuthServer](./docs/utils/neeto-auth-server.md)
+- [NeetoChatWidget](./docs/utils/neeto-chat-widget.md)
 - [Util functions](./docs/utils)
 - [POMs](./docs/poms)
 - [Integration](./docs/integration)

package/index.cjs.js

@@ -60529,7 +60529,7 @@ class RailsEmailUtils {
         });
         return otp || undefined;
     };
-    getEmailAttachment = async (attachmentName, messageSearchCriteria = {}, { receivedAfter = new Date(new Date().valueOf() - 60 * 60 * 1000), expectedEmailCount = 1, timeout = 10_000, } = {}, shouldThrowErrorOnTimeout = true) => {
+    getEmailAttachment = async ({ name, type }, messageSearchCriteria = {}, { receivedAfter = new Date(new Date().valueOf() - 60 * 60 * 1000), expectedEmailCount = 1, timeout = 10_000, } = {}, shouldThrowErrorOnTimeout = true) => {
         const attachmentDetails = (await this.neetoPlaywrightUtilities.executeRecursively({
             callback: async () => {
                 const railsEmail = await this.railsEmailClient.getLatestEmail({
@@ -60538,7 +60538,11 @@ class RailsEmailUtils {
                 });
                 if (!railsEmail)
                     return null;
-                const attachment = railsEmail.attachments?.find(att => att.name.includes(attachmentName));
+                const attachment = railsEmail.attachments?.find(att => {
+                    const matchesName = name ? att.name?.includes(name) : true;
+                    const matchesType = type ? att.type?.startsWith(type) : true;
+                    return matchesName && matchesType;
+                });
                 if (!attachment)
                     return null;
                 return {
@@ -60722,19 +60726,26 @@ class MailerUtils {
         return codes?.[0];
     };
     generateRandomEmail = () => faker.faker.internet.email({ provider: process.env.FASTMAIL_DOMAIN_NAME });
-    getEmailAttachment = async (attachmentName, messageSearchCriteria = {}, { timeout = 10_000, receivedAfter = dateTimeOneHourAgo(), expectedEmailCount = 1, } = {}, shouldThrowErrorOnTimeout = true) => {
-        if (IS_DEV_ENV) {
-            return this.railsEmailUtils.getEmailAttachment(attachmentName, messageSearchCriteria, { receivedAfter, expectedEmailCount, timeout: timeout / 3 }, shouldThrowErrorOnTimeout);
-        }
+    getEmailAttachment = async ({ name, type }, messageSearchCriteria = {}, { timeout = 10_000, receivedAfter = dateTimeOneHourAgo(), expectedEmailCount = 1, } = {}, shouldThrowErrorOnTimeout = true) => {
+        if (IS_DEV_ENV)
+            return this.railsEmailUtils.getEmailAttachment({ name, type }, messageSearchCriteria, { receivedAfter, expectedEmailCount, timeout: timeout / 3 }, shouldThrowErrorOnTimeout);
         const { blobId, attachments: attachmentNameAndTypes } = await this.findMessage(messageSearchCriteria, { expectedEmailCount, receivedAfter, timeout }, shouldThrowErrorOnTimeout);
-        const attachment = attachmentNameAndTypes.find(attachment => attachment.name.includes(attachmentName));
+        const attachment = attachmentNameAndTypes.find(att => {
+            const matchesName = name ? att.name?.includes(name) : true;
+            const matchesType = type ? att.type?.startsWith(type) : true;
+            return matchesName && matchesType;
+        });
         if (!attachment)
             throw new Error("No such attachment exists");
         const emailAttachment = await this.fastmailApi.fetchAttachments(blobId, attachment.name);
         const buffer = await emailAttachment.body();
         const parsedEmail = await mailparserExports.simpleParser(buffer);
         const attachments = parsedEmail.attachments;
-        return attachments.find(attachment => attachment.filename.includes(attachmentName));
+        return attachments.find(att => {
+            const matchesName = name ? att.filename?.includes(name) : true;
+            const matchesType = type ? att.contentType?.startsWith(type) : true;
+            return matchesName && matchesType;
+        });
     };
 }
 
@@ -125124,22 +125135,22 @@ async function warmup({ urls = DEFAULT_WARMUP_URLS, timeout = 60_000, } = {}) {
     }
 }
 
-const CONFIG = {
+const CONFIG$1 = {
     DIR: "/tmp/neeto-auth-web",
     LOG: "/tmp/neeto-auth-server.log",
     PORT: 9000,
     MAX_WAIT_MS: 120_000,
     EMAIL_INIT: "/tmp/neeto-auth-web/config/initializers/playwright_email_capture.rb",
 };
-const SCRIPTS_DIR = path__namespace.join(__dirname, "scripts", "neeto-auth");
+const SCRIPTS_DIR$1 = path__namespace.join(__dirname, "scripts", "neeto-auth");
 const escapeRubyString = (value) => value.replace(/\\/g, "\\\\").replace(/"/g, '\\"');
 const buildEmailCaptureInitializer = (targetApp) => {
-    const template = fs__namespace.readFileSync(path__namespace.join(SCRIPTS_DIR, "playwright_email_capture.rb.template"), "utf-8");
+    const template = fs__namespace.readFileSync(path__namespace.join(SCRIPTS_DIR$1, "playwright_email_capture.rb.template"), "utf-8");
     return template.replace("{{TARGET_APP}}", escapeRubyString(targetApp));
 };
-const log = (msg) => console.log(`[NeetoAuth] ${msg}`);
-const sleep = (ms) => new Promise(resolve => setTimeout(resolve, ms));
-const httpCheck = (port, timeout = 3000) => new Promise(resolve => {
+const log$1 = (msg) => console.log(`[NeetoAuth] ${msg}`);
+const sleep$1 = (ms) => new Promise(resolve => setTimeout(resolve, ms));
+const httpCheck$1 = (port, timeout = 3000) => new Promise(resolve => {
     const req = http__namespace.get(`http://localhost:${port}/`, () => resolve(true));
     req.on("error", () => resolve(false));
     req.setTimeout(timeout, () => {
@@ -125166,7 +125177,7 @@ class NeetoAuthServer {
         while (Date.now() < deadline) {
             try {
                 process.kill(pid, 0);
-                await sleep(500);
+                await sleep$1(500);
             }
             catch {
                 return;
@@ -125175,27 +125186,27 @@ class NeetoAuthServer {
     };
     killServerOnPort = async () => {
         try {
-            child_process.execSync(`lsof -ti tcp:${CONFIG.PORT} | xargs kill -9`, {
+            child_process.execSync(`lsof -ti tcp:${CONFIG$1.PORT} | xargs kill -9`, {
                 stdio: "ignore",
             });
-            await sleep(1000);
+            await sleep$1(1000);
         }
         catch {
             // No process on that port — nothing to kill.
         }
     };
     ensureSetup = () => {
-        if (fs__namespace.existsSync(`${CONFIG.DIR}/Gemfile`)) {
-            log("Already set up, skipping.");
+        if (fs__namespace.existsSync(`${CONFIG$1.DIR}/Gemfile`)) {
+            log$1("Already set up, skipping.");
             return;
         }
         if (!process.env.GITHUB_TOKEN) {
             throw new Error("[NeetoAuth] GITHUB_TOKEN is not set. Cannot clone neeto-auth-web.");
         }
-        log("Running first-time setup...");
-        const setupScript = path__namespace.join(SCRIPTS_DIR, "setup.sh");
+        log$1("Running first-time setup...");
+        const setupScript = path__namespace.join(SCRIPTS_DIR$1, "setup.sh");
         try {
-            child_process.execSync(`bash "${setupScript}" "${CONFIG.DIR}"`, {
+            child_process.execSync(`bash "${setupScript}" "${CONFIG$1.DIR}"`, {
                 stdio: "inherit",
                 env: this.serverEnv,
             });
@@ -125203,73 +125214,73 @@ class NeetoAuthServer {
         catch {
             throw new Error("[NeetoAuth] First-time setup failed. Check the output above for details.");
         }
-        log("Setup complete.");
+        log$1("Setup complete.");
     };
-    waitForServer = async (timeoutMs = CONFIG.MAX_WAIT_MS) => {
+    waitForServer = async (timeoutMs = CONFIG$1.MAX_WAIT_MS) => {
         const startTime = Date.now();
         while (Date.now() - startTime < timeoutMs) {
             if (this.process !== null && this.process.exitCode !== null) {
-                const logContent = fs__namespace.existsSync(CONFIG.LOG)
-                    ? fs__namespace.readFileSync(CONFIG.LOG, "utf-8")
+                const logContent = fs__namespace.existsSync(CONFIG$1.LOG)
+                    ? fs__namespace.readFileSync(CONFIG$1.LOG, "utf-8")
                     : "<no log file>";
                 throw new Error(`[NeetoAuth] Server process exited unexpectedly with code ${this.process.exitCode}.\nLog:\n${logContent}`);
             }
-            if (await httpCheck(CONFIG.PORT))
+            if (await httpCheck$1(CONFIG$1.PORT))
                 return;
-            await sleep(3000);
+            await sleep$1(3000);
         }
-        const logContent = fs__namespace.existsSync(CONFIG.LOG)
-            ? fs__namespace.readFileSync(CONFIG.LOG, "utf-8")
+        const logContent = fs__namespace.existsSync(CONFIG$1.LOG)
+            ? fs__namespace.readFileSync(CONFIG$1.LOG, "utf-8")
             : "<no log file>";
         throw new Error(`[NeetoAuth] Server did not start within ${timeoutMs / 1000}s.\nLog:\n${logContent}`);
     };
     injectEmailCaptureInitializer = () => {
-        fs__namespace.writeFileSync(CONFIG.EMAIL_INIT, buildEmailCaptureInitializer(this.targetApp));
+        fs__namespace.writeFileSync(CONFIG$1.EMAIL_INIT, buildEmailCaptureInitializer(this.targetApp));
     };
     isRunningForCurrentApp = () => {
-        if (!fs__namespace.existsSync(CONFIG.EMAIL_INIT))
+        if (!fs__namespace.existsSync(CONFIG$1.EMAIL_INIT))
             return false;
-        const currentContent = fs__namespace.readFileSync(CONFIG.EMAIL_INIT, "utf-8");
+        const currentContent = fs__namespace.readFileSync(CONFIG$1.EMAIL_INIT, "utf-8");
         return currentContent === buildEmailCaptureInitializer(this.targetApp);
     };
     start = async () => {
         if (IS_STAGING_ENV)
             return;
-        if (await httpCheck(CONFIG.PORT)) {
+        if (await httpCheck$1(CONFIG$1.PORT)) {
             if (this.isRunningForCurrentApp()) {
-                log("Server already running for this app.");
+                log$1("Server already running for this app.");
                 return;
             }
-            log("Server running for a different app — restarting...");
+            log$1("Server running for a different app — restarting...");
             await this.killServerOnPort();
         }
         this.ensureSetup();
         this.injectEmailCaptureInitializer();
-        log("Starting server...");
-        const logStream = fs__namespace.createWriteStream(CONFIG.LOG);
+        log$1("Starting server...");
+        const logStream = fs__namespace.createWriteStream(CONFIG$1.LOG);
         this.process = child_process.spawn("bundle", [
             "exec",
             "rails",
             "server",
             "-p",
-            CONFIG.PORT.toString(),
+            CONFIG$1.PORT.toString(),
             "-b",
             "0.0.0.0",
         ], {
-            cwd: CONFIG.DIR,
+            cwd: CONFIG$1.DIR,
             stdio: ["ignore", "pipe", "pipe"],
             env: this.serverEnv,
         });
         this.process.stdout?.pipe(logStream);
         this.process.stderr?.pipe(logStream);
         await this.waitForServer();
-        log("Server ready.");
+        log$1("Server ready.");
     };
     stop = async () => {
         if (IS_STAGING_ENV || !this.process)
             return;
         const pid = this.process.pid;
-        log("Stopping server...");
+        log$1("Stopping server...");
         this.process.kill("SIGTERM");
         this.process = null;
         if (pid) {
@@ -125278,6 +125289,238 @@ class NeetoAuthServer {
     };
 }
 
+const CONFIG = {
+    DIR: "/tmp/neeto-chat-widget",
+    LOG: "/tmp/neeto-chat-widget.log",
+    PORT: 8081,
+    MAX_WAIT_MS: 180_000,
+    LOCK_RETRY_MS: 500,
+    SERVER_POLL_INTERVAL_MS: 3000,
+    WEBPACK_DEV_FILE: "/tmp/neeto-chat-widget/webpack.dev.js",
+    LOCK_DIR: "/tmp/neeto-chat-widget.lock",
+    STATE_FILE: "/tmp/neeto-chat-widget.state.json",
+};
+const DEFAULT_STATE = { pid: null, refCount: 0 };
+const WIDGET_BASE_URL = `http://localhost:${CONFIG.PORT}`;
+const SCRIPTS_DIR = path__namespace.join(__dirname, "scripts", "neeto-chat-widget");
+const log = (msg) => console.log(`[NeetoChatWidget] ${msg}`);
+const sleep = (ms) => new Promise(resolve => setTimeout(resolve, ms));
+const httpCheck = (timeout = 3000) => new Promise(resolve => {
+    const req = http__namespace.get(`${WIDGET_BASE_URL}/main.js`, () => resolve(true));
+    req.on("error", () => resolve(false));
+    req.setTimeout(timeout, () => {
+        req.destroy();
+        resolve(false);
+    });
+});
+class NeetoChatWidget {
+    process = null;
+    hasLease = false;
+    logStream = null;
+    get serverEnv() {
+        return { ...process.env };
+    }
+    withLock = async (fn) => {
+        while (true) {
+            try {
+                fs$4.mkdirSync(CONFIG.LOCK_DIR);
+                break;
+            }
+            catch (error) {
+                const nodeError = error;
+                if (nodeError.code !== "EEXIST")
+                    throw error;
+                await sleep(CONFIG.LOCK_RETRY_MS);
+            }
+        }
+        try {
+            return await Promise.resolve(fn());
+        }
+        finally {
+            fs$4.rmSync(CONFIG.LOCK_DIR, { force: true, recursive: true });
+        }
+    };
+    parseState = (raw) => {
+        if (!raw || typeof raw !== "object")
+            return DEFAULT_STATE;
+        const state = raw;
+        const pid = typeof state.pid === "number" ? state.pid : null;
+        const refCount = typeof state.refCount === "number" && state.refCount > 0
+            ? state.refCount
+            : 0;
+        return { pid, refCount };
+    };
+    readState = () => {
+        if (!fs$4.existsSync(CONFIG.STATE_FILE))
+            return DEFAULT_STATE;
+        try {
+            return this.parseState(JSON.parse(fs$4.readFileSync(CONFIG.STATE_FILE, "utf-8")));
+        }
+        catch {
+            return DEFAULT_STATE;
+        }
+    };
+    writeState = (state) => {
+        fs$4.writeFileSync(CONFIG.STATE_FILE, JSON.stringify(state));
+    };
+    clearState = () => {
+        fs$4.existsSync(CONFIG.STATE_FILE) && fs$4.rmSync(CONFIG.STATE_FILE, { force: true });
+    };
+    getLogContent = () => fs$4.existsSync(CONFIG.LOG)
+        ? fs$4.readFileSync(CONFIG.LOG, "utf-8")
+        : "<no log file>";
+    ensureSetup = () => {
+        if (fs$4.existsSync(CONFIG.WEBPACK_DEV_FILE)) {
+            this.patchWebpackPublicPath();
+            log("Already set up, skipping.");
+            return;
+        }
+        fs$4.existsSync(CONFIG.DIR) &&
+            fs$4.rmSync(CONFIG.DIR, { force: true, recursive: true });
+        const setupScript = path__namespace.join(SCRIPTS_DIR, "setup.sh");
+        log("Running first-time setup...");
+        try {
+            child_process.execSync(`bash "${setupScript}" "${CONFIG.DIR}"`, {
+                stdio: "inherit",
+                env: this.serverEnv,
+            });
+        }
+        catch {
+            throw new Error("[NeetoChatWidget] First-time setup failed. Check the output above for details.");
+        }
+        this.patchWebpackPublicPath();
+        log("Setup complete.");
+    };
+    patchWebpackPublicPath = () => {
+        if (!fs$4.existsSync(CONFIG.WEBPACK_DEV_FILE)) {
+            throw new Error(`[NeetoChatWidget] Missing webpack config at ${CONFIG.WEBPACK_DEV_FILE}`);
+        }
+        const fileContent = fs$4.readFileSync(CONFIG.WEBPACK_DEV_FILE, "utf-8");
+        const targetPublicPath = `publicPath: "${WIDGET_BASE_URL}/"`;
+        if (fileContent.includes(targetPublicPath))
+            return;
+        const oldConfig = `    devServer: {\n      contentBase: "./src",\n      allowedHosts: [".lvh.me"],\n    },\n`;
+        const newConfig = `    devServer: {\n      contentBase: "./src",\n      allowedHosts: [".lvh.me"],\n      publicPath: "${WIDGET_BASE_URL}/",\n    },\n    output: {\n      publicPath: "${WIDGET_BASE_URL}/",\n    },\n`;
+        if (!fileContent.includes(oldConfig)) {
+            throw new Error("[NeetoChatWidget] Unable to patch webpack.dev.js for local widget serving.");
+        }
+        fs$4.writeFileSync(CONFIG.WEBPACK_DEV_FILE, fileContent.replace(oldConfig, newConfig));
+    };
+    closeLogStream = () => {
+        if (this.logStream) {
+            this.logStream.end();
+            this.logStream = null;
+        }
+    };
+    waitForProcessExit = async (pid) => {
+        const deadline = Date.now() + 10_000;
+        while (Date.now() < deadline) {
+            try {
+                process.kill(pid, 0);
+                await sleep(500);
+            }
+            catch {
+                return;
+            }
+        }
+    };
+    killServer = (pid) => {
+        if (!pid)
+            return;
+        try {
+            process.kill(pid, "SIGTERM");
+        }
+        catch {
+            // process may already be gone
+        }
+    };
+    killProcessOnWidgetPort = async () => {
+        try {
+            child_process.execSync(`lsof -ti tcp:${CONFIG.PORT} | xargs kill -9`, {
+                stdio: "ignore",
+            });
+            await sleep(1000);
+        }
+        catch {
+            // No process on that port — nothing to kill.
+        }
+    };
+    waitForServer = async (timeoutMs = CONFIG.MAX_WAIT_MS) => {
+        const startTime = Date.now();
+        while (Date.now() - startTime < timeoutMs) {
+            if (this.process !== null && this.process.exitCode !== null) {
+                throw new Error(`[NeetoChatWidget] Server process exited unexpectedly with code ${this.process.exitCode}.\nLog:\n${this.getLogContent()}`);
+            }
+            if (await httpCheck())
+                return;
+            await sleep(CONFIG.SERVER_POLL_INTERVAL_MS);
+        }
+        throw new Error(`[NeetoChatWidget] Widget did not start within ${timeoutMs / 1000}s.\nLog:\n${this.getLogContent()}`);
+    };
+    start = async () => {
+        if (IS_STAGING_ENV)
+            return;
+        await this.withLock(async () => {
+            const state = this.readState();
+            if (await httpCheck()) {
+                this.hasLease = true;
+                this.writeState({ ...state, refCount: state.refCount + 1 });
+                log("Server already running.");
+                return;
+            }
+            this.ensureSetup();
+            log("Starting server...");
+            this.logStream = fs$4.createWriteStream(CONFIG.LOG);
+            this.process = child_process.spawn("yarn", ["start"], {
+                cwd: CONFIG.DIR,
+                stdio: ["ignore", "pipe", "pipe"],
+            });
+            this.process.stdout?.pipe(this.logStream);
+            this.process.stderr?.pipe(this.logStream);
+            try {
+                await this.waitForServer();
+            }
+            catch (error) {
+                const pid = this.process?.pid;
+                this.killServer(pid);
+                pid && (await this.waitForProcessExit(pid));
+                (await httpCheck()) && (await this.killProcessOnWidgetPort());
+                this.process = null;
+                this.closeLogStream();
+                throw error;
+            }
+            this.hasLease = true;
+            this.writeState({
+                pid: this.process.pid ?? null,
+                refCount: state.refCount + 1,
+            });
+            log("Server ready.");
+        });
+    };
+    stop = async () => {
+        if (IS_STAGING_ENV || !this.hasLease)
+            return;
+        await this.withLock(async () => {
+            const state = this.readState();
+            const nextRefCount = Math.max(state.refCount - 1, 0);
+            this.hasLease = false;
+            if (nextRefCount > 0) {
+                this.writeState({ ...state, refCount: nextRefCount });
+                return;
+            }
+            if (state.pid) {
+                log("Stopping server...");
+                this.killServer(state.pid);
+                await this.waitForProcessExit(state.pid);
+                (await httpCheck()) && (await this.killProcessOnWidgetPort());
+            }
+            this.process = null;
+            this.closeLogStream();
+            this.clearState();
+        });
+    };
+}
+
 const NEETO_EMAIL_DELIVERY_TESTING_BASE_URL = "/neeto_email_delivery/api/v1/testing";
 class NeetoEmailDeliveryApi {
     neetoPlaywrightUtilities;
@@ -126226,6 +126469,7 @@ exports.CREDENTIALS = CREDENTIALS;
 exports.CURRENT_TIME_RANGES = CURRENT_TIME_RANGES;
 exports.CUSTOM_DOMAIN_SELECTORS = CUSTOM_DOMAIN_SELECTORS;
 exports.CUSTOM_DOMAIN_SUFFIX = CUSTOM_DOMAIN_SUFFIX;
+exports.ColorPickerUtils = ColorPickerUtils;
 exports.CustomCommands = CustomCommands;
 exports.CustomDomainApi = CustomDomainApi;
 exports.CustomDomainPage = CustomDomainPage;
@@ -126293,6 +126537,7 @@ exports.NEETO_ROUTES = NEETO_ROUTES;
 exports.NEETO_SEO_SELECTORS = NEETO_SEO_SELECTORS;
 exports.NEETO_TEXT_MODIFIER_SELECTORS = NEETO_TEXT_MODIFIER_SELECTORS;
 exports.NeetoAuthServer = NeetoAuthServer;
+exports.NeetoChatWidget = NeetoChatWidget;
 exports.NeetoEmailDeliveryApi = NeetoEmailDeliveryApi;
 exports.NeetoTowerApi = NeetoTowerApi;
 exports.ONBOARDING_SELECTORS = ONBOARDING_SELECTORS;