@agent-native/creative-context 0.6.0 → 0.6.3

package/dist/server/resource-paths.js

@@ -1,4 +1,4 @@
-export const CREATIVE_CONTEXT_LIBRARY_PATH = "/agent#library";
+export const CREATIVE_CONTEXT_LIBRARY_PATH = "/settings/library";
 export function getCreativeContextResourcePath() {
     return CREATIVE_CONTEXT_LIBRARY_PATH;
 }

package/dist/server/resource-paths.js.map

@@ -1 +1 @@
-{"version":3,"file":"resource-paths.js","sourceRoot":"","sources":["../../src/server/resource-paths.ts"],"names":[],"mappings":"AAAA,MAAM,CAAC,MAAM,6BAA6B,GAAG,gBAAgB,CAAC;AAE9D,MAAM,UAAU,8BAA8B;IAC5C,OAAO,6BAA6B,CAAC;AACvC,CAAC"}
+{"version":3,"file":"resource-paths.js","sourceRoot":"","sources":["../../src/server/resource-paths.ts"],"names":[],"mappings":"AAAA,MAAM,CAAC,MAAM,6BAA6B,GAAG,mBAAmB,CAAC;AAEjE,MAAM,UAAU,8BAA8B;IAC5C,OAAO,6BAA6B,CAAC;AACvC,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agent-native/creative-context",
-  "version": "0.6.0",
+  "version": "0.6.3",
   "description": "Shared creative context ingestion, versioning, search, brand DNA, and context-pack primitives for agent-native apps.",
   "homepage": "https://github.com/BuilderIO/agent-native#readme",
   "bugs": {
@@ -57,8 +57,8 @@
     "react-dom": "^19.2.7",
     "typescript-7": "npm:typescript@^7.0.2",
     "vitest": "^4.1.5",
-    "@agent-native/core": "0.141.7",
-    "@agent-native/toolkit": "0.13.2"
+    "@agent-native/core": "0.146.5",
+    "@agent-native/toolkit": "0.13.5"
   },
   "peerDependencies": {
     "@agent-native/core": ">=0.8.0",
@@ -84,6 +84,7 @@
     }
   },
   "optionalDependencies": {
+    "@sparticuz/chromium": "149.0.0",
     "officeparser": "^7.3.0",
     "playwright": "^1.61.1"
   },

package/src/actions/list-context-connections.spec.ts

@@ -17,7 +17,7 @@ describe("creative context connection paths", () => {
         `/_agent-native/connections/oauth/${provider}/start`,
       );
       expect(url.searchParams.get("appId")).toBe(appId);
-      expect(url.searchParams.get("return")).toBe("/agent#library");
+      expect(url.searchParams.get("return")).toBe("/settings/library");
     },
   );
 });

package/src/actions/list-context-connections.ts

@@ -4,7 +4,7 @@ import { z } from "zod";
 
 import { getCreativeContext } from "../server/context.js";
 
-const CREATIVE_CONTEXT_LIBRARY_PATH = "/agent#library";
+const CREATIVE_CONTEXT_LIBRARY_PATH = "/settings/library";
 
 export function creativeContextConnectionPath(input: {
   provider: "google_drive" | "figma" | "notion";

package/src/client/CreativeContextChip.tsx

@@ -99,7 +99,7 @@ export function CreativeContextChip({
 }
 
 export function CreativeContextComposerChip({
-  href = "/agent#library",
+  href = "/settings/library",
   className,
 }: {
   href?: string;

package/src/client/CreativeContextPanel.tsx

@@ -3191,7 +3191,7 @@ export function CreativeContextPanel({
                                   : t("creativeContext.applyBrandContext")}
                               </Button>
                               <Button asChild type="button" variant="outline">
-                                <a href="/agent">
+                                <a href="/settings/agent">
                                   {t("creativeContext.generateWithContext")}
                                   <IconArrowUpRight />
                                 </a>

package/src/client/CreativeContextSettingsLink.tsx

@@ -2,7 +2,7 @@ import { useT } from "@agent-native/core/client/i18n";
 import { IconArrowUpRight, IconBooks } from "@tabler/icons-react";
 
 export function CreativeContextSettingsLink({
-  href = "/agent#library",
+  href = "/settings/library",
 }: {
   href?: string;
 }) {

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

@@ -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).",
+    );
+  });
 });