@agent-native/core 0.84.32 → 0.84.34

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: 4983
+- template files: 4994

package/corpus/core/CHANGELOG.md

@@ -1,5 +1,17 @@
 # @agent-native/core
 
+## 0.84.34
+
+### Patch Changes
+
+- 56f3d91: 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.33
+
+### Patch Changes
+
+- 8cc9620: Keep Nitro/Vite dev servers responsive when native file watchers hit EMFILE or ENOSPC by falling back to polling instead of replacing failed watches with no-ops.
+
 ## 0.84.32
 
 ### Patch Changes

package/corpus/core/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agent-native/core",
-  "version": "0.84.32",
+  "version": "0.84.34",
   "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/use-action.ts

@@ -60,7 +60,11 @@ function defaultActionQueryRetry(
  * it maps action names to their parameter and return types, enabling
  * end-to-end type safety for `useActionQuery` and `useActionMutation`.
  */
-export interface ActionRegistry {}
+declare global {
+  interface AgentNativeActionRegistry {}
+}
+
+export interface ActionRegistry extends AgentNativeActionRegistry {}
 
 /** Resolves to the union of registered action names, or `string` if no registry exists. */
 type ActionName = keyof ActionRegistry extends never

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

@@ -402,6 +402,15 @@ function appendToExistingCspDirective(
   existing.tokens = appendCspTokens(existing.tokens, additions);
 }
 
+function ensureCspDirective(
+  directives: CspDirective[],
+  name: string,
+  tokens: readonly string[],
+): void {
+  if (findCspDirective(directives, name)) return;
+  directives.push({ name, tokens: [...tokens] });
+}
+
 function hasStrictNonceScriptPolicy(tokens: readonly string[]): boolean {
   return tokens.some(
     (token) => token === "'strict-dynamic'" || token.startsWith("'nonce-"),
@@ -480,6 +489,9 @@ function augmentExistingEnforcedCspForFrameworkScripts(
     }
   }
 
+  ensureCspDirective(directives, "object-src", ["'none'"]);
+  ensureCspDirective(directives, "base-uri", ["'self'"]);
+
   return serializeCsp(directives);
 }
 

package/corpus/core/src/vite/action-types-plugin.ts

@@ -280,12 +280,16 @@ type ActionEntry<T> = T extends { default: { run: (...args: infer A) => infer R
     }
   : { result: any; params: Record<string, any> };
 
-declare module "@agent-native/core/client" {
-  interface ActionRegistry {
+declare global {
+  interface AgentNativeActionRegistry {
 ${typeEntries.join("\n")}
   }
 }
 
+declare module "@agent-native/core/client" {
+  interface ActionRegistry extends AgentNativeActionRegistry {}
+}
+
 export {};
 `;
 

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

@@ -1,3 +1,4 @@
+import { EventEmitter } from "events";
 import fs from "fs";
 import type { IncomingMessage, ServerResponse } from "http";
 import { createRequire, syncBuiltinESMExports } from "module";
@@ -36,6 +37,137 @@ const require = createRequire(import.meta.url);
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 let nitroFsWatchGuardInstalled = false;
 
+type FsWatchArgs = [fs.PathLike, ...any[]];
+
+function isFileWatchLimitError(
+  error: NodeJS.ErrnoException | undefined,
+): boolean {
+  return error?.code === "EMFILE" || error?.code === "ENOSPC";
+}
+
+function watchPollingIntervalMs(): number {
+  const raw = Number(process.env.CHOKIDAR_INTERVAL ?? 1000);
+  return Number.isFinite(raw) && raw > 0 ? raw : 1000;
+}
+
+function fsWatchListener(args: FsWatchArgs): fs.WatchListener<string> | null {
+  const maybeOptionsOrListener = args[1];
+  const maybeListener = args[2];
+  if (typeof maybeOptionsOrListener === "function")
+    return maybeOptionsOrListener as fs.WatchListener<string>;
+  if (typeof maybeListener === "function")
+    return maybeListener as fs.WatchListener<string>;
+  return null;
+}
+
+function fsWatchPersistent(args: FsWatchArgs): boolean {
+  const options = args[1];
+  if (!options || typeof options === "function") return true;
+  if (typeof options === "string" || Buffer.isBuffer(options)) return true;
+  return options.persistent !== false;
+}
+
+function directEntrySnapshot(
+  target: string,
+): Map<string, { mtimeMs: number; size: number; directory: boolean }> {
+  const snapshot = new Map<
+    string,
+    { mtimeMs: number; size: number; directory: boolean }
+  >();
+  const stat = fs.statSync(target);
+  if (!stat.isDirectory()) {
+    snapshot.set(path.basename(target), {
+      mtimeMs: stat.mtimeMs,
+      size: stat.size,
+      directory: false,
+    });
+    return snapshot;
+  }
+  for (const entry of fs.readdirSync(target, { withFileTypes: true })) {
+    const entryPath = path.join(target, entry.name);
+    try {
+      const entryStat = fs.statSync(entryPath);
+      snapshot.set(entry.name, {
+        mtimeMs: entryStat.mtimeMs,
+        size: entryStat.size,
+        directory: entryStat.isDirectory(),
+      });
+    } catch {
+      // The entry may have disappeared between readdir and stat.
+    }
+  }
+  return snapshot;
+}
+
+function createPollingFsWatcher(args: FsWatchArgs): fs.FSWatcher {
+  const target = String(args[0]);
+  const listener = fsWatchListener(args);
+  const emitter = new EventEmitter() as fs.FSWatcher;
+  let closed = false;
+  let previous = directEntrySnapshot(target);
+
+  if (listener) emitter.on("change", listener);
+
+  const emitChange = (eventName: "change" | "rename", filename: string) => {
+    emitter.emit("change", eventName, filename);
+  };
+
+  const timer = setInterval(() => {
+    if (closed) return;
+    let next: typeof previous;
+    try {
+      next = directEntrySnapshot(target);
+    } catch (error) {
+      emitter.emit("error", error);
+      return;
+    }
+
+    for (const [filename, current] of next) {
+      const old = previous.get(filename);
+      if (!old) {
+        emitChange("rename", filename);
+        continue;
+      }
+      if (
+        old.mtimeMs !== current.mtimeMs ||
+        old.size !== current.size ||
+        old.directory !== current.directory
+      ) {
+        emitChange("change", filename);
+      }
+    }
+    for (const filename of previous.keys()) {
+      if (!next.has(filename)) emitChange("rename", filename);
+    }
+    previous = next;
+  }, watchPollingIntervalMs());
+
+  if (!fsWatchPersistent(args)) timer.unref();
+
+  emitter.close = () => {
+    if (closed) return;
+    closed = true;
+    clearInterval(timer);
+    emitter.removeAllListeners();
+  };
+  emitter.ref = () => {
+    timer.ref();
+    return emitter;
+  };
+  emitter.unref = () => {
+    timer.unref();
+    return emitter;
+  };
+
+  return emitter;
+}
+
+function warnNitroFsWatchFallback(target: unknown, err: NodeJS.ErrnoException) {
+  console.warn(
+    `[agent-native] Falling back to polling Nitro fs.watch for ${String(target)}: ${err.message}`,
+  );
+}
+
 function installNitroFsWatchGuard(): void {
   if (nitroFsWatchGuardInstalled) return;
   nitroFsWatchGuardInstalled = true;
@@ -49,29 +181,32 @@ function installNitroFsWatchGuard(): void {
       watcher = originalWatch(...args);
     } catch (error) {
       const err = error as NodeJS.ErrnoException;
-      if (err.code !== "EMFILE" && err.code !== "ENOSPC") throw error;
-      console.warn(
-        `[agent-native] Disabled Nitro fs.watch for ${String(args[0])}: ${err.message}`,
-      );
-      return {
-        close() {},
-        on() {
-          return this as fs.FSWatcher;
-        },
-      } as unknown as fs.FSWatcher;
+      if (!isFileWatchLimitError(err)) throw error;
+      warnNitroFsWatchFallback(args[0], err);
+      return createPollingFsWatcher(args as FsWatchArgs);
     }
 
     const originalEmit = watcher.emit.bind(watcher);
+    const originalClose = watcher.close.bind(watcher);
+    let pollingFallback: fs.FSWatcher | undefined;
+
+    watcher.close = (() => {
+      pollingFallback?.close();
+      return originalClose();
+    }) as fs.FSWatcher["close"];
+
     watcher.emit = ((eventName: string | symbol, ...eventArgs: any[]) => {
       const err = eventArgs[0] as NodeJS.ErrnoException | undefined;
-      if (
-        eventName === "error" &&
-        (err?.code === "EMFILE" || err?.code === "ENOSPC")
-      ) {
-        console.warn(
-          `[agent-native] Disabled Nitro fs.watch for ${String(args[0])}: ${err.message}`,
-        );
+      if (eventName === "error" && isFileWatchLimitError(err) && err) {
+        warnNitroFsWatchFallback(args[0], err);
         watcher.close();
+        pollingFallback = createPollingFsWatcher(args as FsWatchArgs);
+        pollingFallback.on("change", (changeEvent, filename) => {
+          originalEmit("change", changeEvent, filename);
+        });
+        pollingFallback.on("error", (pollingError) => {
+          originalEmit("error", pollingError);
+        });
         return false;
       }
       return originalEmit(eventName, ...eventArgs);

package/corpus/templates/design/actions/import-design-source.ts

@@ -0,0 +1,158 @@
+import { defineAction } from "@agent-native/core";
+import { assertAccess } from "@agent-native/core/sharing";
+import { z } from "zod";
+
+import { parseFigmaClipboardHtml } from "../server/lib/figma-import/clipboard.js";
+import { importFigmaBuffer } from "../server/lib/figma-import/processor.js";
+import {
+  normalizeImportedHtmlDocument,
+  resolveImportDesignId,
+  saveImportedDesignFiles,
+  type ImportedDesignFile,
+} from "../server/lib/import-design-files.js";
+
+const MAX_HTML_IMPORT_BYTES = 2 * 1024 * 1024;
+
+function ensureHtmlSize(content: string) {
+  if (Buffer.byteLength(content, "utf8") > MAX_HTML_IMPORT_BYTES) {
+    throw new Error("HTML import content is too large (max 2 MB).");
+  }
+}
+
+function baseFilename(originalName: string | undefined, fallback: string) {
+  return (originalName?.trim() || fallback).replace(/\.[^.]+$/, "") + ".html";
+}
+
+export default defineAction({
+  description:
+    "Import Figma clipboard HTML or standalone HTML into the current Design project as one or more editable screens.",
+  schema: z.object({
+    designId: z
+      .string()
+      .optional()
+      .describe("Design id. Defaults to the active editor navigation state."),
+    sourceType: z.enum(["figma-paste-html", "html-string"]),
+    content: z
+      .string()
+      .max(
+        MAX_HTML_IMPORT_BYTES,
+        "HTML import content is too large (max 2 MB).",
+      ),
+    originalName: z.string().optional(),
+  }),
+  run: async ({ designId, sourceType, content, originalName }) => {
+    ensureHtmlSize(content);
+    const resolvedDesignId = await resolveImportDesignId(designId);
+    await assertAccess("design", resolvedDesignId, "editor");
+
+    if (sourceType === "html-string") {
+      const saved = await saveImportedDesignFiles({
+        designId: resolvedDesignId,
+        sourceType: "html-import",
+        files: [
+          {
+            filename: baseFilename(originalName, "imported-html"),
+            fileType: "html",
+            content: normalizeImportedHtmlDocument(content, "HTML source"),
+            source: { sourceType: "html-string", originalName },
+          },
+        ],
+      });
+      return {
+        ...saved,
+        stats: { sourceKind: "html-string", frameCount: saved.files.length },
+      };
+    }
+
+    const parsed = parseFigmaClipboardHtml(content);
+    const warnings: string[] = [];
+    if (parsed.buffer && parsed.hasFigmaBuffer) {
+      try {
+        const imported = await importFigmaBuffer({
+          buffer: parsed.buffer,
+          filename: originalName ?? "figma-paste.fig",
+          sourceKind: "figma-paste",
+          selection: { nodeId: parsed.meta?.selectedNodeId },
+          meta: parsed.meta,
+        });
+        const files: ImportedDesignFile[] = imported.files.map((file) => ({
+          filename: file.filename,
+          fileType: "html",
+          content: file.content,
+          source: file.source,
+          preferredFrame: {
+            title:
+              typeof file.source?.frameName === "string"
+                ? file.source.frameName
+                : undefined,
+            width: file.width,
+            height: file.height,
+          },
+        }));
+        const saved = await saveImportedDesignFiles({
+          designId: resolvedDesignId,
+          sourceType: "figma-paste",
+          files,
+          warnings: [...warnings, ...imported.warnings],
+        });
+        return { ...saved, stats: imported.stats };
+      } catch (error) {
+        warnings.push(
+          error instanceof Error
+            ? `Figma binary payload could not be decoded: ${error.message}`
+            : "Figma binary payload could not be decoded.",
+        );
+      }
+    } else if (parsed.buffer) {
+      warnings.push(
+        "The clipboard included a Figma buffer, but it was not a supported fig-kiwi payload.",
+      );
+    }
+
+    if (!parsed.fallbackHtml) {
+      throw new Error(
+        "No importable Figma frame data or visible HTML was found in the clipboard.",
+      );
+    }
+    const saved = await saveImportedDesignFiles({
+      designId: resolvedDesignId,
+      sourceType: "figma-paste-fallback",
+      files: [
+        {
+          filename: baseFilename(originalName, "figma-paste"),
+          fileType: "html",
+          content: normalizeImportedHtmlDocument(
+            parsed.fallbackHtml,
+            "Figma clipboard fallback HTML",
+          ),
+          source: {
+            sourceType: "figma-paste-fallback",
+            selectedNodeId: parsed.meta?.selectedNodeId,
+            fileKey: parsed.meta?.fileKey,
+          },
+        },
+      ],
+      warnings,
+    });
+    return {
+      ...saved,
+      stats: {
+        sourceKind: "figma-paste",
+        format: "html-fallback",
+        frameCount: saved.files.length,
+        imageCount: 0,
+        selectedNodeId: parsed.meta?.selectedNodeId,
+      },
+    };
+  },
+  link: ({ result }) => {
+    if (!result || typeof result !== "object") return null;
+    const designId = (result as { designId?: string }).designId;
+    if (!designId) return null;
+    return {
+      url: `/design/${designId}`,
+      label: "Open overview",
+      view: "editor",
+    };
+  },
+});

package/corpus/templates/design/actions/navigate.ts

@@ -18,7 +18,7 @@
  *   --designId   Design ID (for editor/present views)
  *   --editorView Editor mode for designs: single or overview
  *   --inspectorTab Inspector tab for designs: design or tweaks (extensions opens Tools for compatibility)
- *   --leftPanel  Left editor panel: file, agent, assets, tools, tokens, or code
+ *   --leftPanel  Left editor panel: file, agent, assets, import, tools, tokens, or code
  *   --fileId     Screen/file id to focus in the design editor
  *   --filename   Screen filename to focus in the design editor
  *   --tool       Design editor tool to activate
@@ -51,6 +51,7 @@ const designLeftPanelSchema = z.enum([
   "file",
   "agent",
   "assets",
+  "import",
   "tools",
   "tokens",
   "code",
@@ -58,7 +59,7 @@ const designLeftPanelSchema = z.enum([
 
 export default defineAction({
   description:
-    "Navigate the UI to a specific view or path. Views: list, editor, design-systems, present, settings. Use --designId with editor/present views and --designSystemId with design-systems. For designs, use editorView=overview to show the infinite screens canvas, or editorView=single with fileId/filename/screen to focus a screen. Use leftPanel=file|agent|assets|tools|tokens|code to focus the left rail, including the wide Code workspace. Legacy inspectorTab=extensions opens Tools. Use tool to activate a design editor tool.",
+    "Navigate the UI to a specific view or path. Views: list, editor, design-systems, present, settings. Use --designId with editor/present views and --designSystemId with design-systems. For designs, use editorView=overview to show the infinite screens canvas, or editorView=single with fileId/filename/screen to focus a screen. Use leftPanel=file|agent|assets|import|tools|tokens|code to focus the left rail, including Import and the wide Code workspace. Legacy inspectorTab=extensions opens Tools. Use tool to activate a design editor tool.",
   schema: z
     .object({
       view: z

package/corpus/templates/design/actions/view-screen.ts

@@ -136,7 +136,7 @@ function resolveActiveCodeFile(
 
 export default defineAction({
   description:
-    "See what the user is currently looking at on screen. Returns the current navigation state including which design is open, which view they are on (list, editor, design-systems, present, settings), active/focused design screen, selected element, active inspector tab (design or tweaks), active left rail panel (file, agent, assets, tools, tokens, or code), active code file metadata, overview canvas state, plus any pending question overlay. Always call this first before taking any action.",
+    "See what the user is currently looking at on screen. Returns the current navigation state including which design is open, which view they are on (list, editor, design-systems, present, settings), active/focused design screen, selected element, active inspector tab (design or tweaks), active left rail panel (file, agent, assets, import, tools, tokens, or code), active code file metadata, overview canvas state, plus any pending question overlay. Always call this first before taking any action.",
   schema: z.object({}),
   http: false,
   run: async () => {