npm - @agent-native/creative-context - Versions diffs - 0.6.0 → 0.6.2 - Mend

@agent-native/creative-context 0.6.0 → 0.6.2

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (8) hide show

package/dist/connectors/rendered-page.d.ts +7 -11
package/dist/connectors/rendered-page.d.ts.map +1 -1
package/dist/connectors/rendered-page.js +298 -37
package/dist/connectors/rendered-page.js.map +1 -1
package/package.json +3 -2
package/src/connectors/rendered-page.spec.ts +287 -1
package/src/connectors/rendered-page.ts +393 -46
package/src/connectors/website.spec.ts +3 -3

package/src/connectors/rendered-page.spec.ts CHANGED Viewed

@@ -1,10 +1,11 @@
 import { afterEach, describe, expect, it, vi } from "vitest";
 const isBlockedExtensionUrlWithDns = vi.hoisted(() => vi.fn(async () => false));
+const ssrfSafeFetch = vi.hoisted(() => vi.fn());
 vi.mock("@agent-native/core/extensions/url-safety", () => ({
   isBlockedExtensionUrlWithDns,
-  ssrfSafeFetch: vi.fn(),
+  ssrfSafeFetch,
 }));
 const { renderWithPlaywright } = await import("./rendered-page.js");
@@ -12,6 +13,7 @@ const { renderWithPlaywright } = await import("./rendered-page.js");
 describe("renderWithPlaywright lifecycle", () => {
   afterEach(() => {
     vi.useRealTimers();
+    ssrfSafeFetch.mockReset();
   });
   it("closes isolated contexts and reports bounded stabilization failures", async () => {
@@ -91,4 +93,288 @@ describe("renderWithPlaywright lifecycle", () => {
     );
     expect(result.diagnostics).toEqual(expect.arrayContaining(result.warnings));
   });
+  it("hydrates through the SSRF-safe network proxy without forwarding cookies", async () => {
+    ssrfSafeFetch
+      .mockResolvedValueOnce(
+        new Response(
+          "<!doctype html><html><head><title>Proxy example</title></head><body>Hydrated CTA</body></html>",
+          { status: 200, headers: { "content-type": "text/html" } },
+        ),
+      )
+      .mockResolvedValueOnce(
+        new Response(".cta{color:rgb(13 20 27)}", {
+          status: 200,
+          headers: { "content-type": "text/css" },
+        }),
+      );
+    let routeHandler:
+      | ((route: {
+          request: () => {
+            url: () => string;
+            isNavigationRequest: () => boolean;
+            resourceType: () => string;
+            method: () => string;
+            headers: () => Record<string, string>;
+          };
+          continue: () => Promise<void>;
+          abort: () => Promise<void>;
+          fulfill: (options: {
+            status: number;
+            headers: Record<string, string>;
+            body: Uint8Array;
+          }) => Promise<void>;
+        }) => Promise<void>)
+      | undefined;
+    const fulfilled: Array<{
+      status: number;
+      headers: Record<string, string>;
+      body: Uint8Array;
+    }> = [];
+    const invokeRoute = async (
+      url: string,
+      navigation: boolean,
+      type: string,
+    ) => {
+      if (!routeHandler) throw new Error("route handler was not installed");
+      await routeHandler({
+        request: () => ({
+          url: () => url,
+          isNavigationRequest: () => navigation,
+          resourceType: () => type,
+          method: () => "GET",
+          headers: () => ({
+            accept: "text/html",
+            cookie: "session=must-not-forward",
+            "user-agent": "fixture-browser",
+          }),
+        }),
+        continue: async () => undefined,
+        abort: async () => undefined,
+        fulfill: async (options) => {
+          fulfilled.push(options);
+        },
+      });
+    };
+    let evaluateCalls = 0;
+    const page = {
+      async route(_pattern: string, handler: (route: never) => Promise<void>) {
+        routeHandler = handler as typeof routeHandler;
+      },
+      async goto() {
+        await invokeRoute("https://example.com/", true, "document");
+        await invokeRoute(
+          "https://example.com/styles.css",
+          false,
+          "stylesheet",
+        );
+      },
+      async waitForLoadState() {},
+      async title() {
+        return "Proxy example";
+      },
+      url() {
+        return "https://example.com/";
+      },
+      locator() {
+        return { innerText: async () => "Hydrated CTA" };
+      },
+      async setViewportSize() {},
+      async screenshot() {
+        return new Uint8Array([1]);
+      },
+      async evaluate<T>() {
+        evaluateCalls += 1;
+        if (evaluateCalls === 3) {
+          return {
+            title: "Proxy example",
+            text: "Hydrated CTA",
+            assets: [],
+            internalLinks: [],
+            designTokens: {
+              colors: ["rgb(13 20 27)"],
+              typography: [],
+              spacing: [],
+              radii: [],
+              cssVariables: {},
+            },
+          } as T;
+        }
+        return undefined as T;
+      },
+    };
+    const context = {
+      async newPage() {
+        return page;
+      },
+      async close() {},
+    };
+    const browser = {
+      contexts: () => [],
+      async newContext() {
+        return context;
+      },
+      async close() {},
+    };
+    const result = await renderWithPlaywright(
+      {
+        chromium: {
+          async launch() {
+            return browser;
+          },
+          async connectOverCDP() {
+            return browser;
+          },
+        },
+      } as never,
+      { url: "https://example.com/", timeoutMs: 5_000 },
+      [],
+      "local-playwright",
+    );
+    expect(result).toMatchObject({
+      rendered: true,
+      method: "local-playwright",
+      text: "Hydrated CTA",
+    });
+    expect(fulfilled).toHaveLength(2);
+    expect(new TextDecoder().decode(fulfilled[0].body)).toContain(
+      "Proxy example",
+    );
+    expect(ssrfSafeFetch).toHaveBeenCalledTimes(2);
+    expect(ssrfSafeFetch.mock.calls[0][1].headers).toEqual({
+      accept: "text/html",
+      "user-agent": "fixture-browser",
+    });
+  });
+  it("reserves browser resource slots before overlapping proxy fetches", async () => {
+    let releaseFetch!: () => void;
+    const fetchGate = new Promise<void>((resolve) => {
+      releaseFetch = resolve;
+    });
+    let fetchCount = 0;
+    ssrfSafeFetch.mockImplementation(async () => {
+      fetchCount += 1;
+      await fetchGate;
+      return new Response("resource", { status: 200 });
+    });
+    let routeHandler:
+      | ((route: {
+          request: () => {
+            url: () => string;
+            isNavigationRequest: () => boolean;
+            resourceType: () => string;
+            method: () => string;
+            headers: () => Record<string, string>;
+          };
+          continue: () => Promise<void>;
+          abort: (reason?: string) => Promise<void>;
+          fulfill: (options: {
+            status: number;
+            headers: Record<string, string>;
+            body: Uint8Array;
+          }) => Promise<void>;
+        }) => Promise<void>)
+      | undefined;
+    let abortCount = 0;
+    const page = {
+      async route(_pattern: string, handler: (route: never) => Promise<void>) {
+        routeHandler = handler as typeof routeHandler;
+      },
+      async goto() {
+        if (!routeHandler) throw new Error("route handler was not installed");
+        const requests = Array.from({ length: 401 }, (_, index) =>
+          routeHandler!({
+            request: () => ({
+              url: () => `https://example.com/resource-${index}`,
+              isNavigationRequest: () => index === 0,
+              resourceType: () => "script",
+              method: () => "GET",
+              headers: () => ({}),
+            }),
+            continue: async () => undefined,
+            abort: async () => {
+              abortCount += 1;
+            },
+            fulfill: async () => undefined,
+          }),
+        );
+        while (fetchCount < 400) await Promise.resolve();
+        releaseFetch();
+        await Promise.all(requests);
+      },
+      async waitForLoadState() {},
+      async title() {
+        return "Example";
+      },
+      url() {
+        return "https://example.com/";
+      },
+      locator() {
+        return { innerText: async () => "Example" };
+      },
+      async setViewportSize() {},
+      async screenshot() {
+        return new Uint8Array([1]);
+      },
+      async evaluate<T>() {
+        return {
+          title: "Example",
+          text: "Example",
+          assets: [],
+          internalLinks: [],
+          designTokens: {
+            colors: [],
+            typography: [],
+            spacing: [],
+            radii: [],
+            cssVariables: {},
+          },
+        } as T;
+      },
+    };
+    const context = {
+      pages: () => [],
+      async newPage() {
+        return page;
+      },
+      async close() {},
+    };
+    const browser = {
+      contexts: () => [],
+      async newContext() {
+        return context;
+      },
+      async close() {},
+    };
+    const result = await renderWithPlaywright(
+      {
+        chromium: {
+          async launch() {
+            return browser;
+          },
+          async connectOverCDP() {
+            return browser;
+          },
+        },
+      } as never,
+      { url: "https://example.com/", timeoutMs: 5_000 },
+      [],
+      "local-playwright",
+    );
+    expect(fetchCount).toBe(400);
+    expect(abortCount).toBe(1);
+    expect(result.warnings).toContain(
+      "Browser resource budget reached (400 requests).",
+    );
+  });
 });