@builder.io/ai-utils 0.25.0 → 0.25.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@builder.io/ai-utils",
-  "version": "0.25.0",
+  "version": "0.25.2",
   "description": "Builder.io AI utils",
   "type": "module",
   "main": "src/index.js",

package/src/codegen.d.ts

@@ -1522,6 +1522,7 @@ export interface FusionConfig {
     };
     miseLocationPath?: string;
     proxyOrigin?: string;
+    proxyDefaultOrigin?: string;
     setupDependencies?: SetupDependency[];
     projectId?: string;
     branchName?: string;

package/src/projects.d.ts

@@ -461,6 +461,10 @@ interface BranchSharedData {
     /** Whether this branch is for a code review - affects enabled agents and tools */
     type?: BranchType | null;
     agentType?: AgentType | null;
+    /** ID of the last PR review — doubles as the vcpCodeGenEvents completion ID for feedback */
+    lastReviewId?: string | null;
+    /** Timestamp of the last PR review */
+    lastReviewAt?: number | null;
 }
 /**
  * fields that are required in the new branch format, but optional in the legacy branch format.

package/src/proxy.d.ts

@@ -0,0 +1,28 @@
+export interface ProxyConfig {
+    devServerUrl: string | undefined;
+    proxyOrigin: string | undefined;
+    proxyDefaultOrigin: string | undefined;
+    proxyDestination: string | undefined;
+}
+/**
+ * Normalizes proxy configuration by inferring `proxyOrigin` and `proxyDefaultOrigin`
+ * from the `devServerUrl` when they aren't explicitly provided.
+ *
+ * For localhost dev servers, `proxyOrigin` becomes a wildcard port pattern
+ * (e.g. `http://localhost:*`) so that any local port is matched, while
+ * `proxyDefaultOrigin` is set to the exact origin for default routing.
+ *
+ * For non-localhost URLs, both are set to the exact origin.
+ *
+ * When `proxyOrigin` is already set (or derived) but `proxyDefaultOrigin` is not,
+ * the default is inferred from the origin — unless the origin looks like a
+ * glob/pattern (contains `*` or lacks an explicit protocol).
+ *
+ * `proxyDestination` is always passed through unchanged.
+ */
+export declare function getProxyConfig({ devServerUrl, proxyOrigin, proxyDefaultOrigin, proxyDestination, }: ProxyConfig): {
+    proxyOrigin: string | undefined;
+    proxyDefaultOrigin: string | undefined;
+    proxyDestination: string | undefined;
+};
+export declare function isLocalhost(hostname: string | URL): boolean;

package/src/proxy.js

@@ -0,0 +1,56 @@
+/**
+ * Normalizes proxy configuration by inferring `proxyOrigin` and `proxyDefaultOrigin`
+ * from the `devServerUrl` when they aren't explicitly provided.
+ *
+ * For localhost dev servers, `proxyOrigin` becomes a wildcard port pattern
+ * (e.g. `http://localhost:*`) so that any local port is matched, while
+ * `proxyDefaultOrigin` is set to the exact origin for default routing.
+ *
+ * For non-localhost URLs, both are set to the exact origin.
+ *
+ * When `proxyOrigin` is already set (or derived) but `proxyDefaultOrigin` is not,
+ * the default is inferred from the origin — unless the origin looks like a
+ * glob/pattern (contains `*` or lacks an explicit protocol).
+ *
+ * `proxyDestination` is always passed through unchanged.
+ */
+export function getProxyConfig({ devServerUrl, proxyOrigin, proxyDefaultOrigin, proxyDestination, }) {
+    let parsedUrl;
+    if (devServerUrl) {
+        try {
+            parsedUrl = new URL(devServerUrl);
+        }
+        catch (_a) { }
+    }
+    if (!proxyOrigin && parsedUrl) {
+        if (isLocalhost(parsedUrl.hostname)) {
+            proxyOrigin = `${parsedUrl.protocol}//${parsedUrl.hostname}:*`;
+            proxyDefaultOrigin = parsedUrl.origin;
+        }
+        else {
+            proxyOrigin = parsedUrl.origin;
+            proxyDefaultOrigin = parsedUrl.origin;
+        }
+    }
+    if (!proxyDefaultOrigin && proxyOrigin) {
+        const isPattern = proxyOrigin.includes("*") ||
+            (!proxyOrigin.startsWith("https://") &&
+                !proxyOrigin.startsWith("http://"));
+        if (!isPattern) {
+            proxyDefaultOrigin = proxyOrigin;
+        }
+    }
+    return {
+        proxyOrigin,
+        proxyDefaultOrigin,
+        proxyDestination,
+    };
+}
+export function isLocalhost(hostname) {
+    let bare = typeof hostname === "string" ? hostname : hostname.hostname;
+    bare = bare.replace(/^\[|\]$/g, "");
+    return (bare === "localhost" ||
+        bare === "127.0.0.1" ||
+        bare === "::1" ||
+        bare === "0.0.0.0");
+}

package/src/proxy.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/src/proxy.spec.js

@@ -0,0 +1,316 @@
+import { describe, it, expect } from "vitest";
+import { getProxyConfig, isLocalhost } from "./proxy";
+describe("getProxyConfig", () => {
+    describe("when all inputs are undefined", () => {
+        it("should return all undefined values", () => {
+            const result = getProxyConfig({
+                devServerUrl: undefined,
+                proxyOrigin: undefined,
+                proxyDefaultOrigin: undefined,
+                proxyDestination: undefined,
+            });
+            expect(result).toEqual({
+                proxyOrigin: undefined,
+                proxyDefaultOrigin: undefined,
+                proxyDestination: undefined,
+            });
+        });
+    });
+    describe("proxyDestination passthrough", () => {
+        it("should always return proxyDestination unchanged", () => {
+            const result = getProxyConfig({
+                devServerUrl: undefined,
+                proxyOrigin: undefined,
+                proxyDefaultOrigin: undefined,
+                proxyDestination: "https://api.example.com",
+            });
+            expect(result.proxyDestination).toBe("https://api.example.com");
+        });
+        it("should preserve proxyDestination alongside derived values", () => {
+            const result = getProxyConfig({
+                devServerUrl: "http://localhost:3000",
+                proxyOrigin: undefined,
+                proxyDefaultOrigin: undefined,
+                proxyDestination: "https://api.example.com",
+            });
+            expect(result.proxyDestination).toBe("https://api.example.com");
+            expect(result.proxyOrigin).toBeDefined();
+        });
+    });
+    describe("deriving from localhost devServerUrl", () => {
+        it("should create a wildcard port pattern for localhost", () => {
+            const result = getProxyConfig({
+                devServerUrl: "http://localhost:3000",
+                proxyOrigin: undefined,
+                proxyDefaultOrigin: undefined,
+                proxyDestination: undefined,
+            });
+            expect(result.proxyOrigin).toBe("http://localhost:*");
+            expect(result.proxyDefaultOrigin).toBe("http://localhost:3000");
+        });
+        it("should create a wildcard port pattern for 127.0.0.1", () => {
+            const result = getProxyConfig({
+                devServerUrl: "http://127.0.0.1:8080",
+                proxyOrigin: undefined,
+                proxyDefaultOrigin: undefined,
+                proxyDestination: undefined,
+            });
+            expect(result.proxyOrigin).toBe("http://127.0.0.1:*");
+            expect(result.proxyDefaultOrigin).toBe("http://127.0.0.1:8080");
+        });
+        it("should create a wildcard port pattern for [::1] (IPv6 loopback)", () => {
+            const result = getProxyConfig({
+                devServerUrl: "http://[::1]:4200",
+                proxyOrigin: undefined,
+                proxyDefaultOrigin: undefined,
+                proxyDestination: undefined,
+            });
+            expect(result.proxyOrigin).toBe("http://[::1]:*");
+            expect(result.proxyDefaultOrigin).toBe("http://[::1]:4200");
+        });
+        it("should handle 0.0.0.0", () => {
+            const result = getProxyConfig({
+                devServerUrl: "http://0.0.0.0:5173",
+                proxyOrigin: undefined,
+                proxyDefaultOrigin: undefined,
+                proxyDestination: undefined,
+            });
+            expect(result.proxyOrigin).toBe("http://0.0.0.0:*");
+            expect(result.proxyDefaultOrigin).toBe("http://0.0.0.0:5173");
+        });
+        it("should handle https localhost", () => {
+            const result = getProxyConfig({
+                devServerUrl: "https://localhost:3443",
+                proxyOrigin: undefined,
+                proxyDefaultOrigin: undefined,
+                proxyDestination: undefined,
+            });
+            expect(result.proxyOrigin).toBe("https://localhost:*");
+            expect(result.proxyDefaultOrigin).toBe("https://localhost:3443");
+        });
+        it("should handle localhost without explicit port (default 80)", () => {
+            const result = getProxyConfig({
+                devServerUrl: "http://localhost",
+                proxyOrigin: undefined,
+                proxyDefaultOrigin: undefined,
+                proxyDestination: undefined,
+            });
+            expect(result.proxyOrigin).toBe("http://localhost:*");
+            expect(result.proxyDefaultOrigin).toBe("http://localhost");
+        });
+    });
+    describe("deriving from non-localhost devServerUrl", () => {
+        it("should use exact origin for remote URLs", () => {
+            const result = getProxyConfig({
+                devServerUrl: "https://dev.example.com:8080",
+                proxyOrigin: undefined,
+                proxyDefaultOrigin: undefined,
+                proxyDestination: undefined,
+            });
+            expect(result.proxyOrigin).toBe("https://dev.example.com:8080");
+            expect(result.proxyDefaultOrigin).toBe("https://dev.example.com:8080");
+        });
+        it("should use exact origin for remote URL without port", () => {
+            const result = getProxyConfig({
+                devServerUrl: "https://staging.myapp.io",
+                proxyOrigin: undefined,
+                proxyDefaultOrigin: undefined,
+                proxyDestination: undefined,
+            });
+            expect(result.proxyOrigin).toBe("https://staging.myapp.io");
+            expect(result.proxyDefaultOrigin).toBe("https://staging.myapp.io");
+        });
+        it("should strip path from the URL and only use origin", () => {
+            const result = getProxyConfig({
+                devServerUrl: "https://dev.example.com/some/path",
+                proxyOrigin: undefined,
+                proxyDefaultOrigin: undefined,
+                proxyDestination: undefined,
+            });
+            expect(result.proxyOrigin).toBe("https://dev.example.com");
+            expect(result.proxyDefaultOrigin).toBe("https://dev.example.com");
+        });
+    });
+    describe("invalid devServerUrl", () => {
+        it("should not derive anything from an invalid URL", () => {
+            const result = getProxyConfig({
+                devServerUrl: "not-a-url",
+                proxyOrigin: undefined,
+                proxyDefaultOrigin: undefined,
+                proxyDestination: undefined,
+            });
+            expect(result.proxyOrigin).toBeUndefined();
+            expect(result.proxyDefaultOrigin).toBeUndefined();
+        });
+        it("should not derive anything from an empty string", () => {
+            const result = getProxyConfig({
+                devServerUrl: "",
+                proxyOrigin: undefined,
+                proxyDefaultOrigin: undefined,
+                proxyDestination: undefined,
+            });
+            expect(result.proxyOrigin).toBeUndefined();
+            expect(result.proxyDefaultOrigin).toBeUndefined();
+        });
+    });
+    describe("proxyOrigin already provided", () => {
+        it("should not override proxyOrigin from devServerUrl", () => {
+            const result = getProxyConfig({
+                devServerUrl: "http://localhost:3000",
+                proxyOrigin: "https://custom.origin.com",
+                proxyDefaultOrigin: undefined,
+                proxyDestination: undefined,
+            });
+            expect(result.proxyOrigin).toBe("https://custom.origin.com");
+        });
+        it("should infer proxyDefaultOrigin from a non-pattern proxyOrigin", () => {
+            const result = getProxyConfig({
+                devServerUrl: undefined,
+                proxyOrigin: "https://custom.origin.com",
+                proxyDefaultOrigin: undefined,
+                proxyDestination: undefined,
+            });
+            expect(result.proxyDefaultOrigin).toBe("https://custom.origin.com");
+        });
+        it("should infer proxyDefaultOrigin from http:// proxyOrigin", () => {
+            const result = getProxyConfig({
+                devServerUrl: undefined,
+                proxyOrigin: "http://my-server.local:9090",
+                proxyDefaultOrigin: undefined,
+                proxyDestination: undefined,
+            });
+            expect(result.proxyDefaultOrigin).toBe("http://my-server.local:9090");
+        });
+    });
+    describe("pattern proxyOrigin (should not infer proxyDefaultOrigin)", () => {
+        it("should not set proxyDefaultOrigin when proxyOrigin contains a wildcard", () => {
+            const result = getProxyConfig({
+                devServerUrl: undefined,
+                proxyOrigin: "http://localhost:*",
+                proxyDefaultOrigin: undefined,
+                proxyDestination: undefined,
+            });
+            expect(result.proxyOrigin).toBe("http://localhost:*");
+            expect(result.proxyDefaultOrigin).toBeUndefined();
+        });
+        it("should not set proxyDefaultOrigin when proxyOrigin has no protocol", () => {
+            const result = getProxyConfig({
+                devServerUrl: undefined,
+                proxyOrigin: "localhost:3000",
+                proxyDefaultOrigin: undefined,
+                proxyDestination: undefined,
+            });
+            expect(result.proxyOrigin).toBe("localhost:3000");
+            expect(result.proxyDefaultOrigin).toBeUndefined();
+        });
+        it("should not set proxyDefaultOrigin for a bare domain pattern", () => {
+            const result = getProxyConfig({
+                devServerUrl: undefined,
+                proxyOrigin: "*.example.com",
+                proxyDefaultOrigin: undefined,
+                proxyDestination: undefined,
+            });
+            expect(result.proxyOrigin).toBe("*.example.com");
+            expect(result.proxyDefaultOrigin).toBeUndefined();
+        });
+    });
+    describe("proxyDefaultOrigin already provided", () => {
+        it("should not override proxyDefaultOrigin when already set", () => {
+            const result = getProxyConfig({
+                devServerUrl: "http://localhost:3000",
+                proxyOrigin: undefined,
+                proxyDefaultOrigin: "http://localhost:4000",
+                proxyDestination: undefined,
+            });
+            // proxyOrigin is derived from devServerUrl since it was undefined,
+            // but proxyDefaultOrigin is overwritten by the localhost derivation path
+            expect(result.proxyOrigin).toBe("http://localhost:*");
+            // The localhost derivation path sets proxyDefaultOrigin to the parsed origin
+            expect(result.proxyDefaultOrigin).toBe("http://localhost:3000");
+        });
+        it("should keep proxyDefaultOrigin when proxyOrigin is also provided", () => {
+            const result = getProxyConfig({
+                devServerUrl: undefined,
+                proxyOrigin: "https://app.example.com",
+                proxyDefaultOrigin: "https://default.example.com",
+                proxyDestination: undefined,
+            });
+            expect(result.proxyOrigin).toBe("https://app.example.com");
+            expect(result.proxyDefaultOrigin).toBe("https://default.example.com");
+        });
+        it("should keep proxyDefaultOrigin even with a pattern proxyOrigin", () => {
+            const result = getProxyConfig({
+                devServerUrl: undefined,
+                proxyOrigin: "http://localhost:*",
+                proxyDefaultOrigin: "http://localhost:3000",
+                proxyDestination: undefined,
+            });
+            expect(result.proxyOrigin).toBe("http://localhost:*");
+            expect(result.proxyDefaultOrigin).toBe("http://localhost:3000");
+        });
+    });
+    describe("edge cases", () => {
+        it("should handle devServerUrl with query params and hash", () => {
+            const result = getProxyConfig({
+                devServerUrl: "http://localhost:3000?foo=bar#baz",
+                proxyOrigin: undefined,
+                proxyDefaultOrigin: undefined,
+                proxyDestination: undefined,
+            });
+            expect(result.proxyOrigin).toBe("http://localhost:*");
+            expect(result.proxyDefaultOrigin).toBe("http://localhost:3000");
+        });
+        it("should handle devServerUrl with trailing slash", () => {
+            const result = getProxyConfig({
+                devServerUrl: "https://dev.example.com/",
+                proxyOrigin: undefined,
+                proxyDefaultOrigin: undefined,
+                proxyDestination: undefined,
+            });
+            expect(result.proxyOrigin).toBe("https://dev.example.com");
+            expect(result.proxyDefaultOrigin).toBe("https://dev.example.com");
+        });
+        it("should not derive proxyOrigin when devServerUrl is provided but proxyOrigin is already set", () => {
+            const result = getProxyConfig({
+                devServerUrl: "http://localhost:3000",
+                proxyOrigin: "http://already-set.com",
+                proxyDefaultOrigin: undefined,
+                proxyDestination: undefined,
+            });
+            expect(result.proxyOrigin).toBe("http://already-set.com");
+            // Should infer proxyDefaultOrigin from the non-pattern proxyOrigin
+            expect(result.proxyDefaultOrigin).toBe("http://already-set.com");
+        });
+        it("should handle all values being pre-set (no-op)", () => {
+            const result = getProxyConfig({
+                devServerUrl: "http://localhost:3000",
+                proxyOrigin: "http://my-origin.com",
+                proxyDefaultOrigin: "http://my-default.com",
+                proxyDestination: "http://my-dest.com",
+            });
+            expect(result).toEqual({
+                proxyOrigin: "http://my-origin.com",
+                proxyDefaultOrigin: "http://my-default.com",
+                proxyDestination: "http://my-dest.com",
+            });
+        });
+    });
+});
+describe("isLocalhost", () => {
+    it.each([
+        ["localhost", true],
+        ["127.0.0.1", true],
+        ["::1", true],
+        ["[::1]", true],
+        ["0.0.0.0", true],
+        ["[127.0.0.1]", true],
+        ["example.com", false],
+        ["192.168.1.1", false],
+        ["10.0.0.1", false],
+        ["localhostx", false],
+        ["[localhost]", true],
+        ["", false],
+    ])("isLocalhost(%s) should be %s", (hostname, expected) => {
+        expect(isLocalhost(hostname)).toBe(expected);
+    });
+});