PSF: Foundry Progress Sync. 57 high-fidelity blueprints established. Open Fleet routing (Kimi/Qwen) active. GTD updated.

projects/org-skill-web-research/node_modules/playwright-extra/dist/puppeteer-compatiblity-shim/index.d.ts

@@ -0,0 +1,25 @@
+import type * as pw from 'playwright-core';
+export declare type PlaywrightObject = pw.Page | pw.Frame | pw.Browser;
+export interface PuppeteerBrowserShim {
+    isCompatShim?: boolean;
+    isPlaywright?: boolean;
+    pages?: pw.BrowserContext['pages'];
+    userAgent: () => Promise<'string'>;
+}
+export interface PuppeteerPageShim {
+    isCompatShim?: boolean;
+    isPlaywright?: boolean;
+    browser?: () => pw.Browser;
+    evaluateOnNewDocument?: pw.Page['addInitScript'];
+    _client: () => pw.CDPSession;
+}
+export declare const isPlaywrightPage: (obj: unknown) => obj is pw.Page;
+export declare const isPlaywrightFrame: (obj: unknown) => obj is pw.Frame;
+export declare const isPlaywrightBrowser: (obj: unknown) => obj is pw.Browser;
+export declare const isPuppeteerCompat: (obj?: unknown) => obj is PlaywrightObject;
+/** Augment a Playwright object with compatibility with certain Puppeteer methods */
+export declare function addPuppeteerCompat<Input extends pw.Page | pw.Frame | pw.Browser | null>(object: Input): Input;
+export declare function getPageCDPSession(page: pw.Page | pw.Frame): Promise<pw.CDPSession>;
+export declare function getBrowserCDPSession(browser: pw.Browser): Promise<pw.CDPSession>;
+export declare function createPageShim(page: pw.Page | pw.Frame): pw.Page | pw.Frame;
+export declare function createBrowserShim(browser: pw.Browser): pw.Browser;

projects/org-skill-web-research/node_modules/playwright-extra/dist/puppeteer-compatiblity-shim/index.js

@@ -0,0 +1,206 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createBrowserShim = exports.createPageShim = exports.getBrowserCDPSession = exports.getPageCDPSession = exports.addPuppeteerCompat = exports.isPuppeteerCompat = exports.isPlaywrightBrowser = exports.isPlaywrightFrame = exports.isPlaywrightPage = void 0;
+const debug_1 = __importDefault(require("debug"));
+const debug = (0, debug_1.default)('playwright-extra:puppeteer-compat');
+const isPlaywrightPage = (obj) => {
+    return 'unroute' in obj;
+};
+exports.isPlaywrightPage = isPlaywrightPage;
+const isPlaywrightFrame = (obj) => {
+    return ['parentFrame', 'frameLocator'].every(x => x in obj);
+};
+exports.isPlaywrightFrame = isPlaywrightFrame;
+const isPlaywrightBrowser = (obj) => {
+    return 'newContext' in obj;
+};
+exports.isPlaywrightBrowser = isPlaywrightBrowser;
+const isPuppeteerCompat = (obj) => {
+    return !!obj && typeof obj === 'object' && !!obj.isCompatShim;
+};
+exports.isPuppeteerCompat = isPuppeteerCompat;
+const cache = {
+    objectToShim: new Map(),
+    cdpSession: {
+        page: new Map(),
+        browser: new Map()
+    }
+};
+/** Augment a Playwright object with compatibility with certain Puppeteer methods */
+function addPuppeteerCompat(object) {
+    if (!object || typeof object !== 'object') {
+        return object;
+    }
+    if (cache.objectToShim.has(object)) {
+        return cache.objectToShim.get(object);
+    }
+    if ((0, exports.isPuppeteerCompat)(object)) {
+        return object;
+    }
+    debug('addPuppeteerCompat', cache.objectToShim.size);
+    if ((0, exports.isPlaywrightPage)(object) || (0, exports.isPlaywrightFrame)(object)) {
+        const shim = createPageShim(object);
+        cache.objectToShim.set(object, shim);
+        return shim;
+    }
+    if ((0, exports.isPlaywrightBrowser)(object)) {
+        const shim = createBrowserShim(object);
+        cache.objectToShim.set(object, shim);
+        return shim;
+    }
+    debug('Received unknown object:', Reflect.ownKeys(object));
+    return object;
+}
+exports.addPuppeteerCompat = addPuppeteerCompat;
+// Only chromium browsers support CDP
+const dummyCDPClient = {
+    send: async (...args) => {
+        debug('dummy CDP client called', 'send', args);
+    },
+    on: (...args) => {
+        debug('dummy CDP client called', 'on', args);
+    }
+};
+async function getPageCDPSession(page) {
+    let session = cache.cdpSession.page.get(page);
+    if (session) {
+        debug('getPageCDPSession: use existing');
+        return session;
+    }
+    debug('getPageCDPSession: use new');
+    const context = (0, exports.isPlaywrightFrame)(page)
+        ? page.page().context()
+        : page.context();
+    try {
+        session = await context.newCDPSession(page);
+        cache.cdpSession.page.set(page, session);
+        return session;
+    }
+    catch (err) {
+        debug('getPageCDPSession: error while creating session:', err.message);
+        debug('getPageCDPSession: Unable create CDP session (most likely a different browser than chromium) - returning a dummy');
+    }
+    return dummyCDPClient;
+}
+exports.getPageCDPSession = getPageCDPSession;
+async function getBrowserCDPSession(browser) {
+    let session = cache.cdpSession.browser.get(browser);
+    if (session) {
+        debug('getBrowserCDPSession: use existing');
+        return session;
+    }
+    debug('getBrowserCDPSession: use new');
+    try {
+        session = await browser.newBrowserCDPSession();
+        cache.cdpSession.browser.set(browser, session);
+        return session;
+    }
+    catch (err) {
+        debug('getBrowserCDPSession: error while creating session:', err.message);
+        debug('getBrowserCDPSession: Unable create CDP session (most likely a different browser than chromium) - returning a dummy');
+    }
+    return dummyCDPClient;
+}
+exports.getBrowserCDPSession = getBrowserCDPSession;
+function createPageShim(page) {
+    const objId = Math.random().toString(36).substring(2, 7);
+    const shim = new Proxy(page, {
+        get(target, prop) {
+            if (prop === 'isCompatShim' || prop === 'isPlaywright') {
+                return true;
+            }
+            debug('page - get', objId, prop);
+            if (prop === '_client') {
+                return () => ({
+                    send: async (method, params) => {
+                        const session = await getPageCDPSession(page);
+                        return await session.send(method, params);
+                    },
+                    on: (event, listener) => {
+                        getPageCDPSession(page).then(session => {
+                            session.on(event, listener);
+                        });
+                    }
+                });
+            }
+            if (prop === 'setBypassCSP') {
+                return async (enabled) => {
+                    const session = await getPageCDPSession(page);
+                    return await session.send('Page.setBypassCSP', {
+                        enabled
+                    });
+                };
+            }
+            if (prop === 'setUserAgent') {
+                return async (userAgent, userAgentMetadata) => {
+                    const session = await getPageCDPSession(page);
+                    return await session.send('Emulation.setUserAgentOverride', {
+                        userAgent,
+                        userAgentMetadata
+                    });
+                };
+            }
+            if (prop === 'browser') {
+                if ((0, exports.isPlaywrightPage)(page)) {
+                    return () => {
+                        let browser = page.context().browser();
+                        if (!browser) {
+                            debug('page.browser() - not available, most likely due to launchPersistentContext');
+                            // Use a page shim as quick drop-in (so browser.userAgent() still works)
+                            browser = page;
+                        }
+                        return addPuppeteerCompat(browser);
+                    };
+                }
+            }
+            if (prop === 'evaluateOnNewDocument') {
+                if ((0, exports.isPlaywrightPage)(page)) {
+                    return async function (pageFunction, ...args) {
+                        return await page.addInitScript(pageFunction, args[0]);
+                    };
+                }
+            }
+            // Only relevant when page is being used a pseudo stand-in for the browser object (launchPersistentContext)
+            if (prop === 'userAgent') {
+                return async (enabled) => {
+                    const session = await getPageCDPSession(page);
+                    const data = await session.send('Browser.getVersion');
+                    return data.userAgent;
+                };
+            }
+            return Reflect.get(target, prop);
+        }
+    });
+    return shim;
+}
+exports.createPageShim = createPageShim;
+function createBrowserShim(browser) {
+    const objId = Math.random().toString(36).substring(2, 7);
+    const shim = new Proxy(browser, {
+        get(target, prop) {
+            if (prop === 'isCompatShim' || prop === 'isPlaywright') {
+                return true;
+            }
+            debug('browser - get', objId, prop);
+            if (prop === 'pages') {
+                return () => browser
+                    .contexts()
+                    .flatMap(c => c.pages().map(page => addPuppeteerCompat(page)));
+            }
+            if (prop === 'userAgent') {
+                return async () => {
+                    const session = await getBrowserCDPSession(browser);
+                    const data = await session.send('Browser.getVersion');
+                    return data.userAgent;
+                };
+            }
+            return Reflect.get(target, prop);
+        }
+    });
+    return shim;
+}
+exports.createBrowserShim = createBrowserShim;
+//# sourceMappingURL=index.js.map

projects/org-skill-web-research/node_modules/playwright-extra/dist/puppeteer-compatiblity-shim/playwright-shim.d.ts

@@ -0,0 +1,11 @@
+// Playwright objects extended with puppeteer compatiblity shims
+
+import type {} from 'playwright-core'
+
+import type { PuppeteerPageShim, PuppeteerBrowserShim } from '.'
+
+declare module 'playwright-core' {
+  interface Page extends PuppeteerPageShim {}
+  interface Frame extends PuppeteerPageShim {}
+  interface Browser extends PuppeteerBrowserShim {}
+}