@agent-native/core 0.84.27 → 0.84.29

package/corpus/README.md

@@ -28,4 +28,4 @@ rg -n "defineAction|useActionQuery" node_modules/@agent-native/core/corpus
 ## Generated Counts
 
 - core files: 2043
-- template files: 4971
+- template files: 4972

package/corpus/core/CHANGELOG.md

@@ -1,5 +1,17 @@
 # @agent-native/core
 
+## 0.84.29
+
+### Patch Changes
+
+- 5f60aaa: Fix hosted Google Analytics / Tag Manager injection by baking the measurement id into Nitro server bundles and merging the required GA/GTM script, connect, and image hosts into existing stricter document CSPs.
+
+## 0.84.28
+
+### Patch Changes
+
+- ffd5b99: Make agent chat thread handoffs robust when opening the panel from external UI controls.
+
 ## 0.84.27
 
 ### Patch Changes

package/corpus/core/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agent-native/core",
-  "version": "0.84.27",
+  "version": "0.84.29",
   "description": "Framework for agent-native application development — where AI agents and UI share SQL state, actions, and context",
   "homepage": "https://github.com/BuilderIO/agent-native#readme",
   "bugs": {

package/corpus/core/src/client/MultiTabAssistantChat.tsx

@@ -26,7 +26,9 @@ import {
   AGENT_CHAT_REMOVE_CONTEXT_MESSAGE_TYPE,
   AGENT_CHAT_SET_CONTEXT_MESSAGE_TYPE,
   appendAgentChatContextToMessage,
+  claimAgentChatOpenRequest,
   claimAgentChatSubmit,
+  drainBufferedAgentChatOpenRequests,
   drainBufferedAgentChatSubmits,
   normalizeAgentChatContextItem,
   parseSubmitChatMessage,
@@ -2087,11 +2089,12 @@ export function MultiTabAssistantChat({
   useEffect(() => {
     const handleOpenThread = (event: Event) => {
       const detail = (event as CustomEvent).detail as
-        | { threadId?: unknown; newThread?: unknown }
+        | { threadId?: unknown; newThread?: unknown; openRequestId?: unknown }
         | undefined;
       const threadId =
         typeof detail?.threadId === "string" ? detail.threadId : "";
-      if (!threadId) return;
+      if (!detail || !threadId) return;
+      if (!claimAgentChatOpenRequest(detail.openRequestId)) return;
 
       if (detail?.newThread === true) {
         newThreadIds.current.add(threadId);
@@ -2143,6 +2146,7 @@ export function MultiTabAssistantChat({
       const detail = (e as CustomEvent).detail;
       const threadId = detail?.threadId;
       if (!threadId) return;
+      if (!claimAgentChatOpenRequest(detail.openRequestId)) return;
       dismissedSubAgentTabsRef.current.delete(threadId);
       // Prefer an explicit parent (RunsTray/background hydration knows it);
       // inline task cards fall back to the active orchestrator thread.
@@ -2196,6 +2200,17 @@ export function MultiTabAssistantChat({
     return () => window.removeEventListener("agent-task-open", handleOpenTask);
   }, [openTabIds, switchThread, refreshThreads, parentMap]);
 
+  // Replay thread/task opens requested before this lazy panel's listeners
+  // attached. Live events claim their id; replay drains only unclaimed requests.
+  useEffect(() => {
+    const buffered = drainBufferedAgentChatOpenRequests();
+    for (const request of buffered) {
+      window.dispatchEvent(
+        new CustomEvent(request.eventType, { detail: request.detail }),
+      );
+    }
+  }, []);
+
   // Watch for agent-issued chat-command in application-state
   const lastChatCommandRef = useRef(0);
   useEffect(() => {

package/corpus/core/src/client/agent-chat.ts

@@ -130,6 +130,26 @@ export interface AgentChatContextState {
   updatedAt: number;
 }
 
+export interface AgentChatOpenThreadRequest {
+  threadId: string;
+  newThread?: boolean;
+  openRequestId?: string;
+}
+
+export interface AgentChatOpenTaskRequest {
+  threadId: string;
+  parentThreadId?: string;
+  description?: string;
+  name?: string;
+  openRequestId?: string;
+}
+
+export type BufferedAgentChatOpenRequest = {
+  id: string;
+  eventType: "agent-chat:open-thread" | "agent-task-open";
+  detail: AgentChatOpenThreadRequest | AgentChatOpenTaskRequest;
+};
+
 export interface AgentComposerReference {
   label: string;
   icon?: string;
@@ -243,6 +263,14 @@ const SELF_SUBMIT_BUFFER_TTL_MS = 8000;
 const bufferedSelfSubmits: BufferedSelfSubmit[] = [];
 const claimedSubmitIds = new Set<string>();
 
+interface BufferedOpenRequest extends BufferedAgentChatOpenRequest {
+  at: number;
+}
+
+const OPEN_REQUEST_BUFFER_TTL_MS = 8000;
+const bufferedOpenRequests: BufferedOpenRequest[] = [];
+const claimedOpenRequestIds = new Set<string>();
+
 function pruneSelfSubmitBuffer(now: number): void {
   for (let i = bufferedSelfSubmits.length - 1; i >= 0; i -= 1) {
     if (now - bufferedSelfSubmits[i].at > SELF_SUBMIT_BUFFER_TTL_MS) {
@@ -261,6 +289,32 @@ function bufferSelfSubmit(data: Record<string, unknown>): void {
   bufferedSelfSubmits.push({ id, data, at: now });
 }
 
+function pruneOpenRequestBuffer(now: number): void {
+  for (let i = bufferedOpenRequests.length - 1; i >= 0; i -= 1) {
+    if (now - bufferedOpenRequests[i].at > OPEN_REQUEST_BUFFER_TTL_MS) {
+      const [removed] = bufferedOpenRequests.splice(i, 1);
+      if (removed) claimedOpenRequestIds.delete(removed.id);
+    }
+  }
+}
+
+function bufferOpenRequest(
+  eventType: BufferedAgentChatOpenRequest["eventType"],
+  detail: AgentChatOpenThreadRequest | AgentChatOpenTaskRequest,
+): BufferedOpenRequest {
+  const now = Date.now();
+  pruneOpenRequestBuffer(now);
+  const id = `open-${now}-${Math.random().toString(36).slice(2, 8)}`;
+  const entry: BufferedOpenRequest = {
+    id,
+    eventType,
+    detail: { ...detail, openRequestId: id },
+    at: now,
+  };
+  bufferedOpenRequests.push(entry);
+  return entry;
+}
+
 /** Unclaimed self-submit payloads, for the panel to replay once it mounts. */
 export function drainBufferedAgentChatSubmits(): Array<
   Record<string, unknown>
@@ -279,10 +333,28 @@ export function claimAgentChatSubmit(id: string | undefined): boolean {
   return true;
 }
 
+/** Unclaimed open-thread/task requests, for the panel to replay once it mounts. */
+export function drainBufferedAgentChatOpenRequests(): BufferedAgentChatOpenRequest[] {
+  pruneOpenRequestBuffer(Date.now());
+  return bufferedOpenRequests
+    .filter((entry) => !claimedOpenRequestIds.has(entry.id))
+    .map(({ id, eventType, detail }) => ({ id, eventType, detail }));
+}
+
+/** Claim an open-thread/task request; false if already handled. Idless events pass. */
+export function claimAgentChatOpenRequest(id: unknown): boolean {
+  if (typeof id !== "string" || !id) return true;
+  if (claimedOpenRequestIds.has(id)) return false;
+  claimedOpenRequestIds.add(id);
+  return true;
+}
+
 /** Test-only: reset the self-submit buffer and claim set. */
 export function _resetAgentChatSubmitBufferForTests(): void {
   bufferedSelfSubmits.length = 0;
   claimedSubmitIds.clear();
+  bufferedOpenRequests.length = 0;
+  claimedOpenRequestIds.clear();
 }
 
 export function normalizeAgentChatContextItem(
@@ -638,6 +710,52 @@ function postAgentChatReferenceMessage(
   }
 }
 
+function openAgentPanelForChat(): void {
+  if (typeof window === "undefined") return;
+  window.dispatchEvent(
+    new CustomEvent("agent-panel:set-mode", {
+      detail: { mode: "chat" },
+    }),
+  );
+  window.dispatchEvent(new CustomEvent("agent-panel:open"));
+}
+
+function dispatchBufferedOpenRequest(entry: BufferedOpenRequest): void {
+  if (typeof window === "undefined") return;
+  const dispatch = () => {
+    window.dispatchEvent(
+      new CustomEvent(entry.eventType, { detail: entry.detail }),
+    );
+  };
+  setTimeout(dispatch, 0);
+}
+
+export function requestAgentChatThreadOpen(
+  detail: AgentChatOpenThreadRequest,
+): void {
+  if (typeof window === "undefined" || !detail.threadId.trim()) return;
+  openAgentPanelForChat();
+  dispatchBufferedOpenRequest(
+    bufferOpenRequest("agent-chat:open-thread", {
+      ...detail,
+      threadId: detail.threadId.trim(),
+    }),
+  );
+}
+
+export function requestAgentTaskOpen(detail: AgentChatOpenTaskRequest): void {
+  if (typeof window === "undefined" || !detail.threadId.trim()) return;
+  openAgentPanelForChat();
+  const parentThreadId = detail.parentThreadId?.trim();
+  dispatchBufferedOpenRequest(
+    bufferOpenRequest("agent-task-open", {
+      ...detail,
+      threadId: detail.threadId.trim(),
+      ...(parentThreadId ? { parentThreadId } : {}),
+    }),
+  );
+}
+
 function isMcpAppChatBridgeEnabled(): boolean {
   if (typeof window === "undefined" || window.parent === window) return false;
   if (readEmbedMcpChatBridgeFlagFromUrl()) markEmbedMcpChatBridgeActive();

package/corpus/core/src/client/index.ts

@@ -16,12 +16,16 @@ export {
   normalizeAgentComposerReference,
   refreshAgentChatContext,
   removeAgentChatContextItem,
+  requestAgentChatThreadOpen,
+  requestAgentTaskOpen,
   sendToAgentChat,
   parseSubmitChatMessage,
   setAgentChatContextItem,
   setContextToAgentChat,
   generateTabId,
   type ParsedSubmitChat,
+  type AgentChatOpenTaskRequest,
+  type AgentChatOpenThreadRequest,
   type AgentChatContextItem,
   type AgentChatContextMessage,
   type AgentChatContextMutationOptions,

package/corpus/core/src/deploy/build.ts

@@ -2886,6 +2886,11 @@ export default bundle;
     virtual: {
       "virtual:agents-bundle": agentsBundleModuleSource,
     },
+    replace: {
+      "process.env.AGENT_NATIVE_BUILD_GA_MEASUREMENT_ID": JSON.stringify(
+        process.env.GA_MEASUREMENT_ID?.trim() || "",
+      ),
+    },
     // Replace browser-only renderers (Excalidraw/Mermaid) with an inert proxy in
     // the server bundle. Without this, Nitro's Rolldown build pulls the real
     // Excalidraw into a shared vendor chunk imported statically by the SSR render

package/corpus/core/src/server/analytics.ts

@@ -4,8 +4,8 @@
  * - `GA_MEASUREMENT_ID` — Google Analytics 4 measurement ID
  *
  * Netlify configuration-file env vars are build-time only for serverless
- * functions, so the Vite plugin also bakes this public value into SSR bundles
- * as `__AGENT_NATIVE_BUILD_GA_MEASUREMENT_ID__`.
+ * functions, so the Vite/Nitro build paths also bake this public value into
+ * SSR bundles.
  *
  * Amplitude and Sentry are initialized client-side via their npm packages
  * (see `packages/core/src/client/analytics.ts`). Only GA requires script
@@ -28,14 +28,17 @@ function normalizeMeasurementId(value: string | undefined): string | null {
   return trimmed ? trimmed : null;
 }
 
+function getViteBakedGaMeasurementId(): string | undefined {
+  return typeof __AGENT_NATIVE_BUILD_GA_MEASUREMENT_ID__ === "string"
+    ? __AGENT_NATIVE_BUILD_GA_MEASUREMENT_ID__
+    : undefined;
+}
+
 function getGaMeasurementId(): string | null {
   return (
     normalizeMeasurementId(process.env.GA_MEASUREMENT_ID) ||
-    normalizeMeasurementId(
-      typeof __AGENT_NATIVE_BUILD_GA_MEASUREMENT_ID__ === "string"
-        ? __AGENT_NATIVE_BUILD_GA_MEASUREMENT_ID__
-        : undefined,
-    )
+    normalizeMeasurementId(process.env.AGENT_NATIVE_BUILD_GA_MEASUREMENT_ID) ||
+    normalizeMeasurementId(getViteBakedGaMeasurementId())
   );
 }
 
@@ -51,6 +54,25 @@ export const GA_CSP_SCRIPT_HOSTS = [
   "https://www.google-analytics.com",
 ] as const;
 
+/**
+ * Network/image hosts used by the GA4 loader when it sends page-view and event
+ * beacons. These are separate from `script-src`: a stricter deployment CSP with
+ * `connect-src 'self'` or `img-src 'self'` can load gtag.js but still drop all
+ * analytics events unless these hosts are present too.
+ */
+export const GA_CSP_CONNECT_HOSTS = [
+  "https://www.google-analytics.com",
+  "https://analytics.google.com",
+  "https://stats.g.doubleclick.net",
+  "https://region1.google-analytics.com",
+] as const;
+
+export const GA_CSP_IMG_HOSTS = [
+  "https://www.google-analytics.com",
+  "https://www.googletagmanager.com",
+  "https://stats.g.doubleclick.net",
+] as const;
+
 /**
  * The exact JS body (no surrounding `<script>` tags) of the inline gtag config
  * block injected next to the gtag.js loader. Returned so the SSR handler can

package/corpus/core/src/server/ssr-handler.ts

@@ -31,6 +31,8 @@ import {
   withAgentNativeSocialImageCacheBuster,
 } from "../shared/social-meta.js";
 import {
+  GA_CSP_CONNECT_HOSTS,
+  GA_CSP_IMG_HOSTS,
   GA_CSP_SCRIPT_HOSTS,
   getGaInlineConfigScriptBody,
 } from "./analytics.js";
@@ -270,6 +272,121 @@ function extractScriptBody(scriptTag: string | null): string | null {
   return scriptTag.slice(start, end);
 }
 
+type CspDirective = {
+  name: string;
+  tokens: string[];
+};
+
+function parseCsp(policy: string): CspDirective[] {
+  return policy
+    .split(";")
+    .map((part) => part.trim())
+    .filter(Boolean)
+    .map((part) => {
+      const [name = "", ...tokens] = part.split(/\s+/);
+      return { name: name.toLowerCase(), tokens };
+    })
+    .filter((directive) => directive.name);
+}
+
+function serializeCsp(directives: CspDirective[]): string {
+  return directives
+    .map((directive) =>
+      [directive.name, ...directive.tokens].filter(Boolean).join(" "),
+    )
+    .join("; ");
+}
+
+function appendCspTokens(
+  tokens: string[],
+  additions: readonly string[],
+): string[] {
+  if (!additions.length) return tokens;
+  const next = tokens.filter((token) => token !== "'none'");
+  const seen = new Set(next);
+  for (const token of additions) {
+    if (!token || seen.has(token)) continue;
+    next.push(token);
+    seen.add(token);
+  }
+  return next;
+}
+
+function findCspDirective(
+  directives: CspDirective[],
+  name: string,
+): CspDirective | undefined {
+  return directives.find((directive) => directive.name === name);
+}
+
+function appendToExistingOrDefaultCspDirective(
+  directives: CspDirective[],
+  name: string,
+  additions: readonly string[],
+): void {
+  if (!additions.length) return;
+  const existing = findCspDirective(directives, name);
+  if (existing) {
+    existing.tokens = appendCspTokens(existing.tokens, additions);
+    return;
+  }
+
+  const defaultSrc = findCspDirective(directives, "default-src");
+  if (!defaultSrc) return;
+  directives.push({
+    name,
+    tokens: appendCspTokens([...defaultSrc.tokens], additions),
+  });
+}
+
+function appendToExistingCspDirective(
+  directives: CspDirective[],
+  name: string,
+  additions: readonly string[],
+): void {
+  const existing = findCspDirective(directives, name);
+  if (!existing) return;
+  existing.tokens = appendCspTokens(existing.tokens, additions);
+}
+
+function augmentExistingCspForFrameworkScripts(
+  policy: string,
+  options: {
+    scriptSrcTokens: readonly string[];
+    gaEnabled: boolean;
+  },
+): string {
+  const directives = parseCsp(policy);
+  if (!directives.length) return policy;
+
+  appendToExistingOrDefaultCspDirective(
+    directives,
+    "script-src",
+    options.scriptSrcTokens,
+  );
+  // `script-src-elem` overrides `script-src` for script tags when present.
+  appendToExistingCspDirective(
+    directives,
+    "script-src-elem",
+    options.scriptSrcTokens,
+  );
+
+  if (options.gaEnabled) {
+    appendToExistingOrDefaultCspDirective(
+      directives,
+      "connect-src",
+      GA_CSP_CONNECT_HOSTS,
+    );
+    appendToExistingOrDefaultCspDirective(
+      directives,
+      "img-src",
+      GA_CSP_IMG_HOSTS,
+    );
+  }
+
+  return serializeCsp(directives);
+}
+
 /**
  * Apply a Content-Security-Policy header to HTML document responses.
  *
@@ -282,20 +399,27 @@ function extractScriptBody(scriptTag: string | null): string | null {
  *     user-controlled content reaches the HTML).
  *
  * A third directive, `script-src`, is emitted via `Content-Security-Policy-
- * Report-Only` rather than enforced. The framework injects deterministic inline
- * scripts (the Sentry config block, whose hash is computed once at process
- * startup from the resolved env vars, and — when `GA_MEASUREMENT_ID` is set —
- * the gtag config block, whose hash is derived from the same string
- * `wrapWithAnalytics` embeds). It also loads Google Tag Manager / GA4 from
- * `GA_CSP_SCRIPT_HOSTS`. All of those are listed here so the report-only policy
- * reflects the code the framework itself injects instead of reporting a
- * violation on every page load. Templates additionally render a theme-init
- * inline script whose exact content varies by template (default theme param,
- * custom docs variant, etc.) and which is rendered by React Router, not this
- * handler, so its hash is not available here. Shipping script-src as
- * Report-Only surfaces the remaining violations without breaking template
- * customisations; teams can graduate to enforcement once their hashes are
- * enumerated.
+ * Report-Only` rather than enforced when the app has no existing document CSP.
+ * The framework injects deterministic inline scripts (the Sentry config block,
+ * whose hash is computed once at process startup from the resolved env vars,
+ * and — when `GA_MEASUREMENT_ID` is set — the gtag config block, whose hash is
+ * derived from the same string `wrapWithAnalytics` embeds). It also loads
+ * Google Tag Manager / GA4 from `GA_CSP_SCRIPT_HOSTS`. All of those are listed
+ * here so the report-only policy reflects the code the framework itself injects
+ * instead of reporting a violation on every page load.
+ *
+ * If an app or host already sends an enforced CSP with `script-src`,
+ * `script-src-elem`, `connect-src`, `img-src`, or `default-src`, we merge the
+ * framework's GA/GTM allowances into the existing directive. That keeps
+ * stricter deployments working without adding a new enforced script policy to
+ * routes that only declare unrelated directives such as `frame-ancestors`.
+ *
+ * Templates additionally render a theme-init inline script whose exact content
+ * varies by template (default theme param, custom docs variant, etc.) and which
+ * is rendered by React Router, not this handler, so its hash is not available
+ * here. Shipping script-src as Report-Only surfaces the remaining violations
+ * without breaking template customisations; teams can graduate to enforcement
+ * once their hashes are enumerated.
  *
  * Skipped in development (`NODE_ENV !== 'production'`) so HMR eval and Vite
  * dev-server injects are never blocked. Set `AGENT_NATIVE_DISABLE_DOC_CSP=1`
@@ -305,16 +429,6 @@ function applyDocumentCsp(headers: Headers, sentryScript: string | null): void {
   if (process.env.NODE_ENV !== "production") return;
   if (process.env.AGENT_NATIVE_DISABLE_DOC_CSP === "1") return;
 
-  // object-src / base-uri: enforced; neither directive mentions scripts, so
-  // they are safe even when a template's inline script hashes are unknown.
-  const existing = headers.get("content-security-policy") ?? "";
-  if (!existing) {
-    headers.set(
-      "content-security-policy",
-      "object-src 'none'; base-uri 'self'",
-    );
-  }
-
   // script-src as Report-Only: list 'self', the framework-injected inline
   // script hashes (Sentry config + gtag config), and the Google Analytics /
   // Tag Manager loader hosts. These are exactly the scripts the framework
@@ -332,11 +446,33 @@ function applyDocumentCsp(headers: Headers, sentryScript: string | null): void {
     ...(gaHash ? [gaHash] : []),
     ...gaHosts,
   ];
-  const scriptSrc = `script-src ${scriptSrcTokens.join(" ")}`;
 
+  const cspAugmentOptions = {
+    scriptSrcTokens,
+    gaEnabled: Boolean(gaInlineBody),
+  };
+  const existing = headers.get("content-security-policy") ?? "";
+  if (!existing) {
+    headers.set(
+      "content-security-policy",
+      "object-src 'none'; base-uri 'self'",
+    );
+  } else {
+    headers.set(
+      "content-security-policy",
+      augmentExistingCspForFrameworkScripts(existing, cspAugmentOptions),
+    );
+  }
+
+  const scriptSrc = `script-src ${scriptSrcTokens.join(" ")}`;
   const existingRo = headers.get("content-security-policy-report-only") ?? "";
   if (!existingRo) {
     headers.set("content-security-policy-report-only", scriptSrc);
+  } else {
+    headers.set(
+      "content-security-policy-report-only",
+      augmentExistingCspForFrameworkScripts(existingRo, cspAugmentOptions),
+    );
   }
 }
 

package/corpus/core/src/vite/client.ts

@@ -2086,6 +2086,9 @@ function createAgentNativeConfig(
       __AGENT_NATIVE_BUILD_GA_MEASUREMENT_ID__: JSON.stringify(
         process.env.GA_MEASUREMENT_ID?.trim() || "",
       ),
+      "process.env.AGENT_NATIVE_BUILD_GA_MEASUREMENT_ID": JSON.stringify(
+        process.env.GA_MEASUREMENT_ID?.trim() || "",
+      ),
       // Framework route warmup controls how SSR `.data` routes are fetched:
       // ordinary fetches keep them CDN-cacheable, while native prefetch headers
       // can be refused before the CDN/origin sees the request. Keep this value