@agent-native/core 0.68.0 → 0.68.2

package/dist/server/core-routes-plugin.js

@@ -60,6 +60,11 @@ import { DEFAULT_SSR_CACHE_HEADERS, EMPTY_SPECULATION_RULES, } from "../shared/c
 export const FRAMEWORK_ROUTE_PREFIX = "/_agent-native";
 export const FRAMEWORK_EVENTS_ROUTE = `${FRAMEWORK_ROUTE_PREFIX}/events`;
 export const LEGACY_FRAMEWORK_EVENTS_ROUTE = `${FRAMEWORK_ROUTE_PREFIX}/poll-events`;
+const DEFAULT_BUILDER_WAITLIST_FORM_ID = "DYTHuM0jlV";
+const DEFAULT_BUILDER_WAITLIST_FORMS_ORIGIN = "https://forms.agent-native.com";
+const BUILDER_WAITLIST_FORM_SOURCE = "connect_builder_card";
+const BUILDER_WAITLIST_FORM_TIMEOUT_MS = 8000;
+const BUILDER_WAITLIST_TEXT_LIMIT = 4000;
 export function resolveFrameworkSseRoutes(sseRoute) {
     return Array.from(new Set([
         sseRoute ?? FRAMEWORK_EVENTS_ROUTE,
@@ -68,6 +73,85 @@ export function resolveFrameworkSseRoutes(sseRoute) {
     ]));
 }
 registerBuiltinEngines();
+function cleanBuilderWaitlistText(value, maxLength = BUILDER_WAITLIST_TEXT_LIMIT) {
+    if (typeof value !== "string")
+        return undefined;
+    const trimmed = value.trim();
+    if (!trimmed)
+        return undefined;
+    return trimmed.slice(0, maxLength);
+}
+function normalizeHttpOrigin(value) {
+    try {
+        const url = new URL(value);
+        if (url.protocol !== "http:" && url.protocol !== "https:")
+            return null;
+        return url.origin;
+    }
+    catch {
+        return null;
+    }
+}
+function isAgentNativeHostedRequest(event) {
+    const hostname = getRequestURL(event).hostname.toLowerCase();
+    return (hostname === "agent-native.com" || hostname.endsWith(".agent-native.com"));
+}
+export function resolveBuilderWaitlistFormTargetForRequest(event) {
+    if (process.env.AGENT_NATIVE_DISABLE_BUILDER_WAITLIST_FORM === "1") {
+        return null;
+    }
+    const envFormId = process.env.AGENT_NATIVE_BUILDER_WAITLIST_FORM_ID?.trim();
+    const envFormsOrigin = process.env.AGENT_NATIVE_BUILDER_WAITLIST_FORMS_ORIGIN?.trim();
+    const hasExplicitTarget = Boolean(envFormId || envFormsOrigin);
+    if (!hasExplicitTarget && !isAgentNativeHostedRequest(event)) {
+        return null;
+    }
+    const formId = envFormId || DEFAULT_BUILDER_WAITLIST_FORM_ID;
+    const formsOrigin = normalizeHttpOrigin(envFormsOrigin || DEFAULT_BUILDER_WAITLIST_FORMS_ORIGIN);
+    if (!formsOrigin) {
+        throw new Error("Invalid Builder waitlist Forms origin");
+    }
+    return { formId, formsOrigin };
+}
+async function submitBuilderWaitlistForm(event, sessionEmail, body) {
+    const target = resolveBuilderWaitlistFormTargetForRequest(event);
+    if (!target)
+        return { submitted: false };
+    const appUrl = cleanBuilderWaitlistText(body.pageUrl ?? body.appUrl, 2000) ??
+        cleanBuilderWaitlistText(getHeader(event, "referer"), 2000) ??
+        getOrigin(event);
+    const source = cleanBuilderWaitlistText(body.source, 100) ?? BUILDER_WAITLIST_FORM_SOURCE;
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), BUILDER_WAITLIST_FORM_TIMEOUT_MS);
+    try {
+        const res = await fetch(`${target.formsOrigin}/api/submit/${encodeURIComponent(target.formId)}`, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({
+                data: {
+                    email: sessionEmail,
+                    orgName: cleanBuilderWaitlistText(body.orgName, 500),
+                    appUrl,
+                    prompt: cleanBuilderWaitlistText(body.prompt),
+                    source,
+                },
+                _hp: "",
+                _meta: {
+                    submitterEmail: sessionEmail,
+                    pageUrl: appUrl,
+                },
+            }),
+            signal: controller.signal,
+        });
+        if (!res.ok) {
+            throw new Error(`Forms waitlist submission failed (${res.status})`);
+        }
+        return { submitted: true, formId: target.formId };
+    }
+    finally {
+        clearTimeout(timeout);
+    }
+}
 function parseBuilderCallbackBoolean(value) {
     if (value == null || value === "")
         return null;
@@ -984,10 +1068,10 @@ export function createCoreRoutesPlugin(options = {}) {
                 });
             }));
             // Branch-creation waitlist signup. Used by ConnectBuilderCard when the
-            // current request has no Builder branch project configured — instead of
-            // the raw 403 from /builder/run, the card surfaces a waitlist CTA that
-            // POSTs here. Recorded as a tracking event so PostHog/Mixpanel/etc.
-            // capture demand without us standing up new storage.
+            // current request has no Builder branch project configured. Hosted
+            // Agent Native deployments submit into the Builder-org Forms waitlist;
+            // local/self-hosted deployments keep the analytics signal without
+            // sending private workspace data to Agent Native.
             getH3App(nitroApp).use(`${P}/builder/branch-waitlist`, defineEventHandler(async (event) => {
                 if (getMethod(event) !== "POST") {
                     setResponseStatus(event, 405);
@@ -998,10 +1082,28 @@ export function createCoreRoutesPlugin(options = {}) {
                     setResponseStatus(event, 401);
                     return { error: "Authentication required" };
                 }
+                const body = ((await readBody(event).catch(() => ({}))) ??
+                    {});
+                let formSubmission;
+                try {
+                    formSubmission = await submitBuilderWaitlistForm(event, session.email, body);
+                }
+                catch (err) {
+                    await trackBuilderLifecycle(event, "builder branch waitlist form failed", session.email, {
+                        reason: err instanceof Error ? err.message : "unknown_waitlist_error",
+                        stage: "waitlist",
+                    });
+                    setResponseStatus(event, 502);
+                    return {
+                        error: "Couldn't join the waitlist. Please try again in a moment.",
+                    };
+                }
                 await trackBuilderLifecycle(event, "builder branch waitlist joined", session.email, {
+                    formId: formSubmission.formId ?? null,
+                    formSubmitted: formSubmission.submitted,
                     stage: "waitlist",
                 });
-                return { ok: true };
+                return { ok: true, formSubmitted: formSubmission.submitted };
             }));
             getH3App(nitroApp).use(`${P}/builder/callback`, defineEventHandler(async (event) => {
                 if (getMethod(event) !== "GET") {