system-testing 1.0.78 → 1.0.81

package/build/browser-process.js

@@ -0,0 +1,134 @@
+import Browser from "./browser.js";
+import BrowserCommandRunner from "./browser-command-runner.js";
+import { browserDaemonStopTimeoutMs } from "./browser-daemon-constants.js";
+import BrowserRegistry from "./browser-registry.js";
+import { WebSocketServer } from "ws";
+/** Long-running browser daemon exposing browser commands over WebSocket. */
+export default class BrowserProcess {
+    /**
+     * @param {object} args
+     * @param {string} args.name
+     * @param {Browser} [args.browser]
+     * @param {Record<string, any>} [args.browserArgs]
+     * @param {string} [args.baseUrl]
+     * @param {boolean} [args.debug]
+     * @param {number} [args.port]
+     */
+    constructor({ name, browser, browserArgs = {}, baseUrl, debug = false, port = 0 }) {
+        /**
+         * @param {import("ws").WebSocket} ws
+         * @returns {void}
+         */
+        this.onConnection = (ws) => {
+            ws.on("message", async (rawData) => {
+                const requestId = `${Date.now()}-${this.requestCount++}`;
+                try {
+                    const payload = JSON.parse(rawData.toString());
+                    const result = await this.handlePayload(payload);
+                    ws.send(JSON.stringify({ ok: true, requestId, result, type: "browser-command-result" }));
+                }
+                catch (error) {
+                    ws.send(JSON.stringify({
+                        error: error instanceof Error ? error.message : String(error),
+                        ok: false,
+                        requestId,
+                        type: "browser-command-result"
+                    }));
+                }
+            });
+        };
+        this.name = name;
+        this.browser = browser ?? new Browser({ debug, ...browserArgs });
+        this.baseUrl = baseUrl;
+        this.debug = debug;
+        this.requestRunner = new BrowserCommandRunner({ browser: this.browser });
+        this.requestCount = 0;
+        this.port = port;
+    }
+    /** @returns {Promise<void>} */
+    async start() {
+        if (!this.name) {
+            throw new Error("Browser process requires a name");
+        }
+        if (this.baseUrl) {
+            this.browser.getDriverAdapter().setBaseUrl(this.baseUrl);
+        }
+        await this.browser.getDriverAdapter().start();
+        await this.browser.setTimeouts(browserDaemonStopTimeoutMs);
+        this.wss = new WebSocketServer({ port: this.port });
+        await new Promise((resolve) => {
+            this.wss.once("listening", resolve);
+        });
+        const address = this.wss.address();
+        if (!address || typeof address === "string") {
+            throw new Error("Could not resolve browser process port");
+        }
+        this.port = address.port;
+        this.wss.on("connection", this.onConnection);
+        await BrowserRegistry.register({
+            baseUrl: this.baseUrl,
+            name: this.name,
+            pid: process.pid,
+            port: this.port,
+            startedAt: new Date().toISOString()
+        });
+        const stop = async () => {
+            await this.stop();
+            process.exit(0);
+        };
+        process.once("SIGINT", stop);
+        process.once("SIGTERM", stop);
+    }
+    /** @returns {Promise<void>} */
+    async stop() {
+        if (this.stopped) {
+            return;
+        }
+        this.stopped = true;
+        await BrowserRegistry.unregister(this.name);
+        if (this.wss) {
+            await new Promise((resolve, reject) => {
+                this.wss.close((error) => {
+                    if (error) {
+                        reject(error);
+                    }
+                    else {
+                        resolve(undefined);
+                    }
+                });
+            });
+        }
+        await this.browser.stopDriver();
+    }
+    /**
+     * @param {Record<string, any>} payload
+     * @returns {Promise<any>}
+     */
+    async handlePayload(payload) {
+        if (payload.type === "browser-daemon") {
+            if (payload.command !== "describe") {
+                throw new Error(`Unknown browser daemon command: ${payload.command}`);
+            }
+            return { name: this.name, pid: process.pid, port: this.port };
+        }
+        if (payload.type !== "browser-command") {
+            throw new Error(`Unknown payload type: ${payload.type}`);
+        }
+        const command = payload.command;
+        const commandArgs = payload.args ? { ...payload.args } : {};
+        if (payload.url && !commandArgs.url) {
+            commandArgs.url = payload.url;
+        }
+        if (payload.path && !commandArgs.path) {
+            commandArgs.path = payload.path;
+        }
+        if (payload.selector && !commandArgs.selector) {
+            commandArgs.selector = payload.selector;
+        }
+        if (payload.testID && !commandArgs.testID) {
+            commandArgs.testID = payload.testID;
+        }
+        return await this.requestRunner.run(command, commandArgs);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"browser-process.js","sourceRoot":"","sources":["../src/browser-process.js"],"names":[],"mappings":"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","sourcesContent":["import Browser from \"./browser.js\"\nimport BrowserCommandRunner from \"./browser-command-runner.js\"\nimport {browserDaemonStopTimeoutMs} from \"./browser-daemon-constants.js\"\nimport BrowserRegistry from \"./browser-registry.js\"\nimport {WebSocketServer} from \"ws\"\n\n/** Long-running browser daemon exposing browser commands over WebSocket. */\nexport default class BrowserProcess {\n  /**\n   * @param {object} args\n   * @param {string} args.name\n   * @param {Browser} [args.browser]\n   * @param {Record<string, any>} [args.browserArgs]\n   * @param {string} [args.baseUrl]\n   * @param {boolean} [args.debug]\n   * @param {number} [args.port]\n   */\n  constructor({name, browser, browserArgs = {}, baseUrl, debug = false, port = 0}) {\n    this.name = name\n    this.browser = browser ?? new Browser({debug, ...browserArgs})\n    this.baseUrl = baseUrl\n    this.debug = debug\n    this.requestRunner = new BrowserCommandRunner({browser: this.browser})\n    this.requestCount = 0\n    this.port = port\n  }\n\n  /** @returns {Promise<void>} */\n  async start() {\n    if (!this.name) {\n      throw new Error(\"Browser process requires a name\")\n    }\n\n    if (this.baseUrl) {\n      this.browser.getDriverAdapter().setBaseUrl(this.baseUrl)\n    }\n\n    await this.browser.getDriverAdapter().start()\n    await this.browser.setTimeouts(browserDaemonStopTimeoutMs)\n\n    this.wss = new WebSocketServer({port: this.port})\n    await new Promise((resolve) => {\n      this.wss.once(\"listening\", resolve)\n    })\n\n    const address = this.wss.address()\n\n    if (!address || typeof address === \"string\") {\n      throw new Error(\"Could not resolve browser process port\")\n    }\n\n    this.port = address.port\n    this.wss.on(\"connection\", this.onConnection)\n\n    await BrowserRegistry.register({\n      baseUrl: this.baseUrl,\n      name: this.name,\n      pid: process.pid,\n      port: this.port,\n      startedAt: new Date().toISOString()\n    })\n\n    const stop = async () => {\n      await this.stop()\n      process.exit(0)\n    }\n\n    process.once(\"SIGINT\", stop)\n    process.once(\"SIGTERM\", stop)\n  }\n\n  /** @returns {Promise<void>} */\n  async stop() {\n    if (this.stopped) {\n      return\n    }\n\n    this.stopped = true\n    await BrowserRegistry.unregister(this.name)\n\n    if (this.wss) {\n      await new Promise((resolve, reject) => {\n        this.wss.close((error) => {\n          if (error) {\n            reject(error)\n          } else {\n            resolve(undefined)\n          }\n        })\n      })\n    }\n\n    await this.browser.stopDriver()\n  }\n\n  /**\n   * @param {import(\"ws\").WebSocket} ws\n   * @returns {void}\n   */\n  onConnection = (ws) => {\n    ws.on(\"message\", async (rawData) => {\n      const requestId = `${Date.now()}-${this.requestCount++}`\n\n      try {\n        const payload = JSON.parse(rawData.toString())\n        const result = await this.handlePayload(payload)\n\n        ws.send(JSON.stringify({ok: true, requestId, result, type: \"browser-command-result\"}))\n      } catch (error) {\n        ws.send(JSON.stringify({\n          error: error instanceof Error ? error.message : String(error),\n          ok: false,\n          requestId,\n          type: \"browser-command-result\"\n        }))\n      }\n    })\n  }\n\n  /**\n   * @param {Record<string, any>} payload\n   * @returns {Promise<any>}\n   */\n  async handlePayload(payload) {\n    if (payload.type === \"browser-daemon\") {\n      if (payload.command !== \"describe\") {\n        throw new Error(`Unknown browser daemon command: ${payload.command}`)\n      }\n\n      return {name: this.name, pid: process.pid, port: this.port}\n    }\n\n    if (payload.type !== \"browser-command\") {\n      throw new Error(`Unknown payload type: ${payload.type}`)\n    }\n\n    const command = payload.command\n    const commandArgs = payload.args ? {...payload.args} : {}\n\n    if (payload.url && !commandArgs.url) {\n      commandArgs.url = payload.url\n    }\n\n    if (payload.path && !commandArgs.path) {\n      commandArgs.path = payload.path\n    }\n\n    if (payload.selector && !commandArgs.selector) {\n      commandArgs.selector = payload.selector\n    }\n\n    if (payload.testID && !commandArgs.testID) {\n      commandArgs.testID = payload.testID\n    }\n\n    return await this.requestRunner.run(command, commandArgs)\n  }\n}\n"]}

package/build/browser-registry.d.ts

@@ -0,0 +1,44 @@
+/** Browser process registry. */
+export default class BrowserRegistry {
+    /** @returns {string} */
+    static getRegistryPath(): string;
+    /** @returns {Promise<Array<Record<string, any>>>} */
+    static list(): Promise<Array<Record<string, any>>>;
+    /**
+     * @param {Record<string, any>} entry
+     * @returns {Promise<void>}
+     */
+    static register(entry: Record<string, any>): Promise<void>;
+    /**
+     * @param {string} name
+     * @returns {Promise<void>}
+     */
+    static unregister(name: string): Promise<void>;
+    /**
+     * @param {string} [name]
+     * @returns {Promise<Record<string, any>>}
+     */
+    static resolve(name?: string): Promise<Record<string, any>>;
+    /**
+     * @param {string} [name]
+     * @returns {Promise<Record<string, any>>}
+     */
+    static stop(name?: string): Promise<Record<string, any>>;
+    /**
+     * @param {Record<string, any>} entry
+     * @returns {Promise<boolean>}
+     */
+    static verifyEntry(entry: Record<string, any>): Promise<boolean>;
+    /**
+     * @param {number} pid
+     * @returns {boolean}
+     */
+    static isProcessAlive(pid: number): boolean;
+    /** @returns {Promise<Array<Record<string, any>>>} */
+    static _readRegistry(): Promise<Array<Record<string, any>>>;
+    /**
+     * @param {Array<Record<string, any>>} entries
+     * @returns {Promise<void>}
+     */
+    static _writeRegistry(entries: Array<Record<string, any>>): Promise<void>;
+}

package/build/browser-registry.js

@@ -0,0 +1,191 @@
+import fs from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import wait from "awaitery/build/wait.js";
+import { WebSocket } from "ws";
+import { browserDaemonStopTimeoutMs, browserDaemonVerifyTimeoutMs } from "./browser-daemon-constants.js";
+const registryPath = path.join(os.tmpdir(), "system-testing-browser-registry.json");
+/** Browser process registry. */
+export default class BrowserRegistry {
+    /** @returns {string} */
+    static getRegistryPath() {
+        return registryPath;
+    }
+    /** @returns {Promise<Array<Record<string, any>>>} */
+    static async list() {
+        const entries = await this._readRegistry();
+        const aliveEntries = [];
+        let dirty = false;
+        for (const entry of entries) {
+            if (this.isProcessAlive(entry.pid)) {
+                aliveEntries.push(entry);
+            }
+            else {
+                dirty = true;
+            }
+        }
+        if (dirty) {
+            await this._writeRegistry(aliveEntries);
+        }
+        return aliveEntries;
+    }
+    /**
+     * @param {Record<string, any>} entry
+     * @returns {Promise<void>}
+     */
+    static async register(entry) {
+        const entries = await this.list();
+        const filteredEntries = entries.filter((existingEntry) => existingEntry.name !== entry.name);
+        filteredEntries.push(entry);
+        await this._writeRegistry(filteredEntries);
+    }
+    /**
+     * @param {string} name
+     * @returns {Promise<void>}
+     */
+    static async unregister(name) {
+        const entries = await this.list();
+        const filteredEntries = entries.filter((entry) => entry.name !== name);
+        await this._writeRegistry(filteredEntries);
+    }
+    /**
+     * @param {string} [name]
+     * @returns {Promise<Record<string, any>>}
+     */
+    static async resolve(name) {
+        const entries = await this.list();
+        if (name) {
+            const entry = entries.find((candidate) => candidate.name === name);
+            if (!entry) {
+                throw new Error(`No running browser process found with name: ${name}`);
+            }
+            return entry;
+        }
+        if (entries.length === 1) {
+            return entries[0];
+        }
+        if (entries.length === 0) {
+            throw new Error("No running browser processes found");
+        }
+        throw new Error(`Multiple browser processes are running (${entries.length}); pass --name`);
+    }
+    /**
+     * @param {string} [name]
+     * @returns {Promise<Record<string, any>>}
+     */
+    static async stop(name) {
+        const entry = await this.resolve(name);
+        if (!(await this.verifyEntry(entry))) {
+            await this.unregister(entry.name);
+            throw new Error(`Browser registry entry ${entry.name} no longer matches a running browser daemon`);
+        }
+        try {
+            process.kill(entry.pid, "SIGTERM");
+        }
+        catch (error) {
+            if (error instanceof Error && "code" in error && error.code === "ESRCH") {
+                await this.unregister(entry.name);
+                return entry;
+            }
+            throw error;
+        }
+        for (let attemptNumber = 1; attemptNumber <= browserDaemonStopTimeoutMs / 50; attemptNumber += 1) {
+            if (!this.isProcessAlive(entry.pid)) {
+                await this.unregister(entry.name);
+                return entry;
+            }
+            await wait(50);
+        }
+        throw new Error(`Timed out waiting for browser process ${entry.name} (${entry.pid}) to stop`);
+    }
+    /**
+     * @param {Record<string, any>} entry
+     * @returns {Promise<boolean>}
+     */
+    static async verifyEntry(entry) {
+        if (typeof entry.port !== "number" || entry.port <= 0) {
+            return false;
+        }
+        const ws = new WebSocket(`ws://127.0.0.1:${entry.port}`);
+        return await new Promise((resolve) => {
+            let settled = false;
+            const finish = (result) => {
+                if (settled) {
+                    return;
+                }
+                settled = true;
+                clearTimeout(timeoutId);
+                try {
+                    ws.close();
+                }
+                catch {
+                    // Ignore close errors while validating a registry entry.
+                }
+                resolve(result);
+            };
+            const timeoutId = setTimeout(() => {
+                finish(false);
+            }, browserDaemonVerifyTimeoutMs);
+            ws.on("open", () => {
+                ws.send(JSON.stringify({ command: "describe", type: "browser-daemon" }));
+            });
+            ws.on("message", (rawData) => {
+                try {
+                    const response = JSON.parse(rawData.toString());
+                    const result = response?.result;
+                    finish(response?.ok === true
+                        && result?.name === entry.name
+                        && result?.pid === entry.pid
+                        && result?.port === entry.port);
+                }
+                catch {
+                    finish(false);
+                }
+            });
+            ws.on("error", () => {
+                finish(false);
+            });
+        });
+    }
+    /**
+     * @param {number} pid
+     * @returns {boolean}
+     */
+    static isProcessAlive(pid) {
+        if (!pid || typeof pid !== "number") {
+            return false;
+        }
+        try {
+            process.kill(pid, 0);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    /** @returns {Promise<Array<Record<string, any>>>} */
+    static async _readRegistry() {
+        try {
+            const fileContent = await fs.readFile(this.getRegistryPath(), "utf8");
+            const parsed = JSON.parse(fileContent);
+            if (!Array.isArray(parsed)) {
+                return [];
+            }
+            return parsed;
+        }
+        catch (error) {
+            if (error instanceof Error && "code" in error && error.code === "ENOENT") {
+                return [];
+            }
+            throw error;
+        }
+    }
+    /**
+     * @param {Array<Record<string, any>>} entries
+     * @returns {Promise<void>}
+     */
+    static async _writeRegistry(entries) {
+        await fs.writeFile(this.getRegistryPath(), JSON.stringify(entries, null, 2));
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"browser-registry.js","sourceRoot":"","sources":["../src/browser-registry.js"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,kBAAkB,CAAA;AACjC,OAAO,EAAE,MAAM,SAAS,CAAA;AACxB,OAAO,IAAI,MAAM,WAAW,CAAA;AAC5B,OAAO,IAAI,MAAM,wBAAwB,CAAA;AACzC,OAAO,EAAC,SAAS,EAAC,MAAM,IAAI,CAAA;AAE5B,OAAO,EAAC,0BAA0B,EAAE,4BAA4B,EAAC,MAAM,+BAA+B,CAAA;AAEtG,MAAM,YAAY,GAAG,IAAI,CAAC,IAAI,CAAC,EAAE,CAAC,MAAM,EAAE,EAAE,sCAAsC,CAAC,CAAA;AAEnF,gCAAgC;AAChC,MAAM,CAAC,OAAO,OAAO,eAAe;IAClC,wBAAwB;IACxB,MAAM,CAAC,eAAe;QACpB,OAAO,YAAY,CAAA;IACrB,CAAC;IAED,qDAAqD;IACrD,MAAM,CAAC,KAAK,CAAC,IAAI;QACf,MAAM,OAAO,GAAG,MAAM,IAAI,CAAC,aAAa,EAAE,CAAA;QAC1C,MAAM,YAAY,GAAG,EAAE,CAAA;QACvB,IAAI,KAAK,GAAG,KAAK,CAAA;QAEjB,KAAK,MAAM,KAAK,IAAI,OAAO,EAAE,CAAC;YAC5B,IAAI,IAAI,CAAC,cAAc,CAAC,KAAK,CAAC,GAAG,CAAC,EAAE,CAAC;gBACnC,YAAY,CAAC,IAAI,CAAC,KAAK,CAAC,CAAA;YAC1B,CAAC;iBAAM,CAAC;gBACN,KAAK,GAAG,IAAI,CAAA;YACd,CAAC;QACH,CAAC;QAED,IAAI,KAAK,EAAE,CAAC;YACV,MAAM,IAAI,CAAC,cAAc,CAAC,YAAY,CAAC,CAAA;QACzC,CAAC;QAED,OAAO,YAAY,CAAA;IACrB,CAAC;IAED;;;OAGG;IACH,MAAM,CAAC,KAAK,CAAC,QAAQ,CAAC,KAAK;QACzB,MAAM,OAAO,GAAG,MAAM,IAAI,CAAC,IAAI,EAAE,CAAA;QACjC,MAAM,eAAe,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC,aAAa,EAAE,EAAE,CAAC,aAAa,CAAC,IAAI,KAAK,KAAK,CAAC,IAAI,CAAC,CAAA;QAE5F,eAAe,CAAC,IAAI,CAAC,KAAK,CAAC,CAAA;QAC3B,MAAM,IAAI,CAAC,cAAc,CAAC,eAAe,CAAC,CAAA;IAC5C,CAAC;IAED;;;OAGG;IACH,MAAM,CAAC,KAAK,CAAC,UAAU,CAAC,IAAI;QAC1B,MAAM,OAAO,GAAG,MAAM,IAAI,CAAC,IAAI,EAAE,CAAA;QACjC,MAAM,eAAe,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,KAAK,CAAC,IAAI,KAAK,IAAI,CAAC,CAAA;QAEtE,MAAM,IAAI,CAAC,cAAc,CAAC,eAAe,CAAC,CAAA;IAC5C,CAAC;IAED;;;OAGG;IACH,MAAM,CAAC,KAAK,CAAC,OAAO,CAAC,IAAI;QACvB,MAAM,OAAO,GAAG,MAAM,IAAI,CAAC,IAAI,EAAE,CAAA;QAEjC,IAAI,IAAI,EAAE,CAAC;YACT,MAAM,KAAK,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC,SAAS,EAAE,EAAE,CAAC,SAAS,CAAC,IAAI,KAAK,IAAI,CAAC,CAAA;YAElE,IAAI,CAAC,KAAK,EAAE,CAAC;gBACX,MAAM,IAAI,KAAK,CAAC,+CAA+C,IAAI,EAAE,CAAC,CAAA;YACxE,CAAC;YAED,OAAO,KAAK,CAAA;QACd,CAAC;QAED,IAAI,OAAO,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;YACzB,OAAO,OAAO,CAAC,CAAC,CAAC,CAAA;QACnB,CAAC;QAED,IAAI,OAAO,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;YACzB,MAAM,IAAI,KAAK,CAAC,oCAAoC,CAAC,CAAA;QACvD,CAAC;QAED,MAAM,IAAI,KAAK,CAAC,2CAA2C,OAAO,CAAC,MAAM,gBAAgB,CAAC,CAAA;IAC5F,CAAC;IAED;;;OAGG;IACH,MAAM,CAAC,KAAK,CAAC,IAAI,CAAC,IAAI;QACpB,MAAM,KAAK,GAAG,MAAM,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,CAAA;QAEtC,IAAI,CAAC,CAAC,MAAM,IAAI,CAAC,WAAW,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC;YACrC,MAAM,IAAI,CAAC,UAAU,CAAC,KAAK,CAAC,IAAI,CAAC,CAAA;YACjC,MAAM,IAAI,KAAK,CAAC,0BAA0B,KAAK,CAAC,IAAI,6CAA6C,CAAC,CAAA;QACpG,CAAC;QAED,IAAI,CAAC;YACH,OAAO,CAAC,IAAI,CAAC,KAAK,CAAC,GAAG,EAAE,SAAS,CAAC,CAAA;QACpC,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,IAAI,KAAK,YAAY,KAAK,IAAI,MAAM,IAAI,KAAK,IAAI,KAAK,CAAC,IAAI,KAAK,OAAO,EAAE,CAAC;gBACxE,MAAM,IAAI,CAAC,UAAU,CAAC,KAAK,CAAC,IAAI,CAAC,CAAA;gBACjC,OAAO,KAAK,CAAA;YACd,CAAC;YAED,MAAM,KAAK,CAAA;QACb,CAAC;QAED,KAAK,IAAI,aAAa,GAAG,CAAC,EAAE,aAAa,IAAI,0BAA0B,GAAG,EAAE,EAAE,aAAa,IAAI,CAAC,EAAE,CAAC;YACjG,IAAI,CAAC,IAAI,CAAC,cAAc,CAAC,KAAK,CAAC,GAAG,CAAC,EAAE,CAAC;gBACpC,MAAM,IAAI,CAAC,UAAU,CAAC,KAAK,CAAC,IAAI,CAAC,CAAA;gBACjC,OAAO,KAAK,CAAA;YACd,CAAC;YAED,MAAM,IAAI,CAAC,EAAE,CAAC,CAAA;QAChB,CAAC;QAED,MAAM,IAAI,KAAK,CAAC,yCAAyC,KAAK,CAAC,IAAI,KAAK,KAAK,CAAC,GAAG,WAAW,CAAC,CAAA;IAC/F,CAAC;IAED;;;OAGG;IACH,MAAM,CAAC,KAAK,CAAC,WAAW,CAAC,KAAK;QAC5B,IAAI,OAAO,KAAK,CAAC,IAAI,KAAK,QAAQ,IAAI,KAAK,CAAC,IAAI,IAAI,CAAC,EAAE,CAAC;YACtD,OAAO,KAAK,CAAA;QACd,CAAC;QAED,MAAM,EAAE,GAAG,IAAI,SAAS,CAAC,kBAAkB,KAAK,CAAC,IAAI,EAAE,CAAC,CAAA;QAExD,OAAO,MAAM,IAAI,OAAO,CAAC,CAAC,OAAO,EAAE,EAAE;YACnC,IAAI,OAAO,GAAG,KAAK,CAAA;YAEnB,MAAM,MAAM,GAAG,CAAC,MAAM,EAAE,EAAE;gBACxB,IAAI,OAAO,EAAE,CAAC;oBACZ,OAAM;gBACR,CAAC;gBAED,OAAO,GAAG,IAAI,CAAA;gBACd,YAAY,CAAC,SAAS,CAAC,CAAA;gBAEvB,IAAI,CAAC;oBACH,EAAE,CAAC,KAAK,EAAE,CAAA;gBACZ,CAAC;gBAAC,MAAM,CAAC;oBACP,yDAAyD;gBAC3D,CAAC;gBAED,OAAO,CAAC,MAAM,CAAC,CAAA;YACjB,CAAC,CAAA;YAED,MAAM,SAAS,GAAG,UAAU,CAAC,GAAG,EAAE;gBAChC,MAAM,CAAC,KAAK,CAAC,CAAA;YACf,CAAC,EAAE,4BAA4B,CAAC,CAAA;YAEhC,EAAE,CAAC,EAAE,CAAC,MAAM,EAAE,GAAG,EAAE;gBACjB,EAAE,CAAC,IAAI,CAAC,IAAI,CAAC,SAAS,CAAC,EAAC,OAAO,EAAE,UAAU,EAAE,IAAI,EAAE,gBAAgB,EAAC,CAAC,CAAC,CAAA;YACxE,CAAC,CAAC,CAAA;YAEF,EAAE,CAAC,EAAE,CAAC,SAAS,EAAE,CAAC,OAAO,EAAE,EAAE;gBAC3B,IAAI,CAAC;oBACH,MAAM,QAAQ,GAAG,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,QAAQ,EAAE,CAAC,CAAA;oBAC/C,MAAM,MAAM,GAAG,QAAQ,EAAE,MAAM,CAAA;oBAE/B,MAAM,CACJ,QAAQ,EAAE,EAAE,KAAK,IAAI;2BAClB,MAAM,EAAE,IAAI,KAAK,KAAK,CAAC,IAAI;2BAC3B,MAAM,EAAE,GAAG,KAAK,KAAK,CAAC,GAAG;2BACzB,MAAM,EAAE,IAAI,KAAK,KAAK,CAAC,IAAI,CAC/B,CAAA;gBACH,CAAC;gBAAC,MAAM,CAAC;oBACP,MAAM,CAAC,KAAK,CAAC,CAAA;gBACf,CAAC;YACH,CAAC,CAAC,CAAA;YAEF,EAAE,CAAC,EAAE,CAAC,OAAO,EAAE,GAAG,EAAE;gBAClB,MAAM,CAAC,KAAK,CAAC,CAAA;YACf,CAAC,CAAC,CAAA;QACJ,CAAC,CAAC,CAAA;IACJ,CAAC;IAED;;;OAGG;IACH,MAAM,CAAC,cAAc,CAAC,GAAG;QACvB,IAAI,CAAC,GAAG,IAAI,OAAO,GAAG,KAAK,QAAQ,EAAE,CAAC;YACpC,OAAO,KAAK,CAAA;QACd,CAAC;QAED,IAAI,CAAC;YACH,OAAO,CAAC,IAAI,CAAC,GAAG,EAAE,CAAC,CAAC,CAAA;YACpB,OAAO,IAAI,CAAA;QACb,CAAC;QAAC,MAAM,CAAC;YACP,OAAO,KAAK,CAAA;QACd,CAAC;IACH,CAAC;IAED,qDAAqD;IACrD,MAAM,CAAC,KAAK,CAAC,aAAa;QACxB,IAAI,CAAC;YACH,MAAM,WAAW,GAAG,MAAM,EAAE,CAAC,QAAQ,CAAC,IAAI,CAAC,eAAe,EAAE,EAAE,MAAM,CAAC,CAAA;YACrE,MAAM,MAAM,GAAG,IAAI,CAAC,KAAK,CAAC,WAAW,CAAC,CAAA;YAEtC,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,MAAM,CAAC,EAAE,CAAC;gBAC3B,OAAO,EAAE,CAAA;YACX,CAAC;YAED,OAAO,MAAM,CAAA;QACf,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,IAAI,KAAK,YAAY,KAAK,IAAI,MAAM,IAAI,KAAK,IAAI,KAAK,CAAC,IAAI,KAAK,QAAQ,EAAE,CAAC;gBACzE,OAAO,EAAE,CAAA;YACX,CAAC;YAED,MAAM,KAAK,CAAA;QACb,CAAC;IACH,CAAC;IAED;;;OAGG;IACH,MAAM,CAAC,KAAK,CAAC,cAAc,CAAC,OAAO;QACjC,MAAM,EAAE,CAAC,SAAS,CAAC,IAAI,CAAC,eAAe,EAAE,EAAE,IAAI,CAAC,SAAS,CAAC,OAAO,EAAE,IAAI,EAAE,CAAC,CAAC,CAAC,CAAA;IAC9E,CAAC;CACF","sourcesContent":["import fs from \"node:fs/promises\"\nimport os from \"node:os\"\nimport path from \"node:path\"\nimport wait from \"awaitery/build/wait.js\"\nimport {WebSocket} from \"ws\"\n\nimport {browserDaemonStopTimeoutMs, browserDaemonVerifyTimeoutMs} from \"./browser-daemon-constants.js\"\n\nconst registryPath = path.join(os.tmpdir(), \"system-testing-browser-registry.json\")\n\n/** Browser process registry. */\nexport default class BrowserRegistry {\n  /** @returns {string} */\n  static getRegistryPath() {\n    return registryPath\n  }\n\n  /** @returns {Promise<Array<Record<string, any>>>} */\n  static async list() {\n    const entries = await this._readRegistry()\n    const aliveEntries = []\n    let dirty = false\n\n    for (const entry of entries) {\n      if (this.isProcessAlive(entry.pid)) {\n        aliveEntries.push(entry)\n      } else {\n        dirty = true\n      }\n    }\n\n    if (dirty) {\n      await this._writeRegistry(aliveEntries)\n    }\n\n    return aliveEntries\n  }\n\n  /**\n   * @param {Record<string, any>} entry\n   * @returns {Promise<void>}\n   */\n  static async register(entry) {\n    const entries = await this.list()\n    const filteredEntries = entries.filter((existingEntry) => existingEntry.name !== entry.name)\n\n    filteredEntries.push(entry)\n    await this._writeRegistry(filteredEntries)\n  }\n\n  /**\n   * @param {string} name\n   * @returns {Promise<void>}\n   */\n  static async unregister(name) {\n    const entries = await this.list()\n    const filteredEntries = entries.filter((entry) => entry.name !== name)\n\n    await this._writeRegistry(filteredEntries)\n  }\n\n  /**\n   * @param {string} [name]\n   * @returns {Promise<Record<string, any>>}\n   */\n  static async resolve(name) {\n    const entries = await this.list()\n\n    if (name) {\n      const entry = entries.find((candidate) => candidate.name === name)\n\n      if (!entry) {\n        throw new Error(`No running browser process found with name: ${name}`)\n      }\n\n      return entry\n    }\n\n    if (entries.length === 1) {\n      return entries[0]\n    }\n\n    if (entries.length === 0) {\n      throw new Error(\"No running browser processes found\")\n    }\n\n    throw new Error(`Multiple browser processes are running (${entries.length}); pass --name`)\n  }\n\n  /**\n   * @param {string} [name]\n   * @returns {Promise<Record<string, any>>}\n   */\n  static async stop(name) {\n    const entry = await this.resolve(name)\n\n    if (!(await this.verifyEntry(entry))) {\n      await this.unregister(entry.name)\n      throw new Error(`Browser registry entry ${entry.name} no longer matches a running browser daemon`)\n    }\n\n    try {\n      process.kill(entry.pid, \"SIGTERM\")\n    } catch (error) {\n      if (error instanceof Error && \"code\" in error && error.code === \"ESRCH\") {\n        await this.unregister(entry.name)\n        return entry\n      }\n\n      throw error\n    }\n\n    for (let attemptNumber = 1; attemptNumber <= browserDaemonStopTimeoutMs / 50; attemptNumber += 1) {\n      if (!this.isProcessAlive(entry.pid)) {\n        await this.unregister(entry.name)\n        return entry\n      }\n\n      await wait(50)\n    }\n\n    throw new Error(`Timed out waiting for browser process ${entry.name} (${entry.pid}) to stop`)\n  }\n\n  /**\n   * @param {Record<string, any>} entry\n   * @returns {Promise<boolean>}\n   */\n  static async verifyEntry(entry) {\n    if (typeof entry.port !== \"number\" || entry.port <= 0) {\n      return false\n    }\n\n    const ws = new WebSocket(`ws://127.0.0.1:${entry.port}`)\n\n    return await new Promise((resolve) => {\n      let settled = false\n\n      const finish = (result) => {\n        if (settled) {\n          return\n        }\n\n        settled = true\n        clearTimeout(timeoutId)\n\n        try {\n          ws.close()\n        } catch {\n          // Ignore close errors while validating a registry entry.\n        }\n\n        resolve(result)\n      }\n\n      const timeoutId = setTimeout(() => {\n        finish(false)\n      }, browserDaemonVerifyTimeoutMs)\n\n      ws.on(\"open\", () => {\n        ws.send(JSON.stringify({command: \"describe\", type: \"browser-daemon\"}))\n      })\n\n      ws.on(\"message\", (rawData) => {\n        try {\n          const response = JSON.parse(rawData.toString())\n          const result = response?.result\n\n          finish(\n            response?.ok === true\n            && result?.name === entry.name\n            && result?.pid === entry.pid\n            && result?.port === entry.port\n          )\n        } catch {\n          finish(false)\n        }\n      })\n\n      ws.on(\"error\", () => {\n        finish(false)\n      })\n    })\n  }\n\n  /**\n   * @param {number} pid\n   * @returns {boolean}\n   */\n  static isProcessAlive(pid) {\n    if (!pid || typeof pid !== \"number\") {\n      return false\n    }\n\n    try {\n      process.kill(pid, 0)\n      return true\n    } catch {\n      return false\n    }\n  }\n\n  /** @returns {Promise<Array<Record<string, any>>>} */\n  static async _readRegistry() {\n    try {\n      const fileContent = await fs.readFile(this.getRegistryPath(), \"utf8\")\n      const parsed = JSON.parse(fileContent)\n\n      if (!Array.isArray(parsed)) {\n        return []\n      }\n\n      return parsed\n    } catch (error) {\n      if (error instanceof Error && \"code\" in error && error.code === \"ENOENT\") {\n        return []\n      }\n\n      throw error\n    }\n  }\n\n  /**\n   * @param {Array<Record<string, any>>} entries\n   * @returns {Promise<void>}\n   */\n  static async _writeRegistry(entries) {\n    await fs.writeFile(this.getRegistryPath(), JSON.stringify(entries, null, 2))\n  }\n}\n"]}

package/build/browser.d.ts

@@ -0,0 +1,240 @@
+/**
+ * @typedef {object} BrowserArgs
+ * @property {boolean} [debug] Enable debug logging.
+ * @property {BrowserDriverConfig} [driver] Driver configuration.
+ * @property {import("./system-test-communicator.js").default} [communicator] Optional command communicator for helper-driven navigation.
+ * @property {string} [screenshotsPath] Directory used for saved screenshots and browser artifacts.
+ */
+/**
+ * @typedef {object} BrowserDriverConfig
+ * @property {"selenium"|"appium"} [type] Driver implementation to use.
+ * @property {Record<string, any>} [options] Driver-specific options.
+ */
+/**
+ * @typedef {object} BrowserNavigationArgs
+ * @property {number} [timeout] Override the timeout for this navigation command.
+ */
+/** Generic browser session wrapper around the configured driver. */
+export default class Browser {
+    /** @param {BrowserArgs} [args] */
+    constructor({ debug, driver, communicator, screenshotsPath, ...restArgs }?: BrowserArgs);
+    /** @type {import("selenium-webdriver").WebDriver | undefined} */
+    driver: import("selenium-webdriver").WebDriver | undefined;
+    /** @type {import("./drivers/webdriver-driver.js").default | undefined} */
+    driverAdapter: import("./drivers/webdriver-driver.js").default | undefined;
+    _debug: boolean;
+    /** @type {BrowserDriverConfig | undefined} */
+    _driverConfig: BrowserDriverConfig | undefined;
+    /** @type {Error | undefined} */
+    _httpServerError: Error | undefined;
+    _screenshotsPath: string;
+    communicator: import("./system-test-communicator.js").default;
+    /**
+     * @param {BrowserDriverConfig} [driverConfig]
+     * @returns {import("./drivers/webdriver-driver.js").default}
+     */
+    createDriver(driverConfig?: BrowserDriverConfig): import("./drivers/webdriver-driver.js").default;
+    /**
+     * @param {import("./system-test-communicator.js").default | undefined} communicator
+     * @returns {void}
+     */
+    setCommunicator(communicator: import("./system-test-communicator.js").default | undefined): void;
+    /** @returns {boolean} */
+    communicatorExists(): boolean;
+    /**
+     * @param {string} baseSelector
+     * @returns {void}
+     */
+    setBaseSelector(baseSelector: string): void;
+    _baseSelector: string;
+    /** @returns {string | undefined} */
+    getBaseSelector(): string | undefined;
+    /**
+     * @param {string} selector
+     * @returns {string}
+     */
+    getSelector(selector: string): string;
+    /**
+     * @param {...any} args
+     * @returns {void}
+     */
+    debugError(...args: any[]): void;
+    /**
+     * @param {...any} args
+     * @returns {void}
+     */
+    debugLog(...args: any[]): void;
+    /** @returns {void} */
+    throwIfHttpServerError(): void;
+    /**
+     * @param {Error} error
+     * @returns {void}
+     */
+    onHttpServerError: (error: Error) => void;
+    /** @returns {import("selenium-webdriver").WebDriver} */
+    getDriver(): import("selenium-webdriver").WebDriver;
+    /** @returns {import("./drivers/webdriver-driver.js").default} */
+    getDriverAdapter(): import("./drivers/webdriver-driver.js").default;
+    /** @returns {number} */
+    getTimeouts(): number;
+    /** @returns {Promise<void>} */
+    restoreTimeouts(): Promise<void>;
+    /**
+     * @param {number} newTimeout
+     * @returns {Promise<void>}
+     */
+    driverSetTimeouts(newTimeout: number): Promise<void>;
+    /**
+     * @param {number} newTimeout
+     * @returns {Promise<void>}
+     */
+    setTimeouts(newTimeout: number): Promise<void>;
+    /** @returns {Promise<string[]>} */
+    getBrowserLogs(): Promise<string[]>;
+    /** @returns {Promise<string>} */
+    getCurrentUrl(): Promise<string>;
+    /**
+     * @param {string} selector
+     * @param {import("./system-test.js").FindArgs} [args]
+     * @returns {Promise<import("selenium-webdriver").WebElement[]>}
+     */
+    all(selector: string, args?: import("./system-test.js").FindArgs): Promise<import("selenium-webdriver").WebElement[]>;
+    /**
+     * @param {string} selector
+     * @param {import("./system-test.js").FindArgs} [args]
+     * @returns {Promise<import("selenium-webdriver").WebElement>}
+     */
+    find(selector: string, args?: import("./system-test.js").FindArgs): Promise<import("selenium-webdriver").WebElement>;
+    /**
+     * @param {string} testID
+     * @param {import("./system-test.js").FindArgs} [args]
+     * @returns {Promise<import("selenium-webdriver").WebElement>}
+     */
+    findByTestID(testID: string, args?: import("./system-test.js").FindArgs): Promise<import("selenium-webdriver").WebElement>;
+    /**
+     * @param {string} selector
+     * @param {import("./system-test.js").FindArgs} [args]
+     * @returns {Promise<import("selenium-webdriver").WebElement>}
+     */
+    findNoWait(selector: string, args?: import("./system-test.js").FindArgs): Promise<import("selenium-webdriver").WebElement>;
+    /**
+     * @param {string | import("selenium-webdriver").WebElement} elementOrIdentifier
+     * @param {import("./system-test.js").FindArgs} [args]
+     * @returns {Promise<void>}
+     */
+    click(elementOrIdentifier: string | import("selenium-webdriver").WebElement, args?: import("./system-test.js").FindArgs): Promise<void>;
+    /**
+     * @param {import("selenium-webdriver").WebElement|string|{selector: string} & import("./system-test.js").FindArgs} elementOrIdentifier
+     * @param {string} methodName
+     * @param {...any} args
+     * @returns {Promise<any>}
+     */
+    interact(elementOrIdentifier: import("selenium-webdriver").WebElement | string | ({
+        selector: string;
+    } & import("./system-test.js").FindArgs), methodName: string, ...args: any[]): Promise<any>;
+    /**
+     * @param {string} selector
+     * @param {import("./system-test.js").WaitForNoSelectorArgs} [args]
+     * @returns {Promise<void>}
+     */
+    waitForNoSelector(selector: string, args?: import("./system-test.js").WaitForNoSelectorArgs): Promise<void>;
+    /**
+     * @param {string} selector
+     * @param {import("./system-test.js").FindArgs} [args]
+     * @returns {Promise<void>}
+     */
+    expectNoElement(selector: string, args?: import("./system-test.js").FindArgs): Promise<void>;
+    /** @returns {Promise<string>} */
+    getHTML(): Promise<string>;
+    /**
+     * @param {number | undefined} timeoutOverride
+     * @returns {number}
+     */
+    getCommandTimeout(timeoutOverride: number | undefined): number;
+    /**
+     * @param {string} path
+     * @returns {Promise<void>}
+     */
+    driverVisit(path: string): Promise<void>;
+    /**
+     * @param {string} type
+     * @param {string} path
+     * @param {BrowserNavigationArgs} [args]
+     * @returns {Promise<void>}
+     */
+    sendBrowserCommand(type: string, path: string, args?: BrowserNavigationArgs): Promise<void>;
+    /**
+     * Visits a path using the injected browser helper when available, otherwise navigates directly with the driver.
+     * @param {string} path
+     * @param {BrowserNavigationArgs} [args]
+     * @returns {Promise<void>}
+     */
+    visit(path: string, args?: BrowserNavigationArgs): Promise<void>;
+    /**
+     * Dismisses to a path via the injected browser helper when available, otherwise navigates directly with the driver.
+     * @param {string} path
+     * @param {BrowserNavigationArgs} [args]
+     * @returns {Promise<void>}
+     */
+    dismissTo(path: string, args?: BrowserNavigationArgs): Promise<void>;
+    /**
+     * Formats browser logs for console output and truncates overly long output.
+     * @param {string[]} logs
+     * @param {number} [maxLines]
+     * @returns {string[]}
+     */
+    formatBrowserLogsForConsole(logs: string[], maxLines?: number): string[];
+    /**
+     * @param {string[]} logs
+     * @returns {void}
+     */
+    printBrowserLogsForFailure(logs: string[]): void;
+    /**
+     * Takes a screenshot, writes HTML/browser logs to disk, and returns the collected artifacts.
+     * @returns {Promise<{currentUrl: string, html: string, htmlPath: string, logs: string[], logsPath: string, screenshotPath: string}>}
+     */
+    takeScreenshot(): Promise<{
+        currentUrl: string;
+        html: string;
+        htmlPath: string;
+        logs: string[];
+        logsPath: string;
+        screenshotPath: string;
+    }>;
+    /** @returns {Promise<void>} */
+    stopDriver(): Promise<void>;
+}
+export type BrowserArgs = {
+    /**
+     * Enable debug logging.
+     */
+    debug?: boolean;
+    /**
+     * Driver configuration.
+     */
+    driver?: BrowserDriverConfig;
+    /**
+     * Optional command communicator for helper-driven navigation.
+     */
+    communicator?: import("./system-test-communicator.js").default;
+    /**
+     * Directory used for saved screenshots and browser artifacts.
+     */
+    screenshotsPath?: string;
+};
+export type BrowserDriverConfig = {
+    /**
+     * Driver implementation to use.
+     */
+    type?: "selenium" | "appium";
+    /**
+     * Driver-specific options.
+     */
+    options?: Record<string, any>;
+};
+export type BrowserNavigationArgs = {
+    /**
+     * Override the timeout for this navigation command.
+     */
+    timeout?: number;
+};