@agent-native/core 0.80.4 → 0.80.5

package/corpus/templates/design/actions/generate-design.ts

@@ -1,4 +1,9 @@
 import { defineAction, embedApp } from "@agent-native/core";
+import {
+  deleteAppState,
+  readAppState,
+  writeAppState,
+} from "@agent-native/core/application-state";
 import {
   hasCollabState,
   applyText,
@@ -18,6 +23,10 @@ import {
   mergeCanvasFramePlacements,
   type CanvasFramePlacement,
 } from "../shared/canvas-frames.js";
+import {
+  designGenerationSessionKey,
+  type DesignGenerationSession,
+} from "../shared/generation-session.js";
 
 /** Editor deep link so external agents can surface "Open design". */
 function designDeepLink(designId: string): string {
@@ -28,6 +37,50 @@ function designDeepLink(designId: string): string {
   });
 }
 
+function isRenderableDesignFile(file: {
+  fileType?: string | null;
+  content?: string | null;
+}): boolean {
+  const fileType = file.fileType ?? "html";
+  return (
+    (fileType === "html" || fileType === "jsx") && Boolean(file.content?.trim())
+  );
+}
+
+async function updateGenerationSessionForSavedFiles(
+  designId: string,
+  savedFilenames: string[],
+) {
+  const key = designGenerationSessionKey(designId);
+  const rawSession = await readAppState(key).catch(() => null);
+  if (!rawSession || typeof rawSession !== "object") return;
+  const session = rawSession as unknown as DesignGenerationSession;
+  if (session.designId !== designId || !Array.isArray(session.frames)) return;
+
+  const saved = new Set(savedFilenames);
+  const frames = session.frames.map((frame) =>
+    frame.filename && saved.has(frame.filename)
+      ? {
+          ...frame,
+          status: "done" as const,
+          step: "Saved",
+          progress: 1,
+        }
+      : frame,
+  );
+  const allDone = frames.every((frame) => frame.status === "done");
+  if (allDone) {
+    await deleteAppState(key);
+    return;
+  }
+
+  await writeAppState(key, {
+    ...session,
+    status: "generating",
+    frames,
+  } as unknown as Record<string, unknown>);
+}
+
 export default defineAction({
   description:
     "Save generated design content to a design project. " +
@@ -181,19 +234,6 @@ export default defineAction({
       }
     }
 
-    const hasRenderableFile = files.some((file) => {
-      const fileType = file.fileType ?? "html";
-      return (
-        (fileType === "html" || fileType === "jsx") &&
-        file.content.trim().length > 0
-      );
-    });
-    if (!hasRenderableFile) {
-      throw new Error(
-        "generate-design requires at least one non-empty HTML or JSX file before the design can be reported as ready",
-      );
-    }
-
     const savedFiles: Array<{
       id: string;
       filename: string;
@@ -206,6 +246,15 @@ export default defineAction({
       .from(schema.designFiles)
       .where(eq(schema.designFiles.designId, designId));
 
+    const hasRenderableFile =
+      files.some(isRenderableDesignFile) ||
+      existingFiles.some(isRenderableDesignFile);
+    if (!hasRenderableFile) {
+      throw new Error(
+        "generate-design requires at least one non-empty HTML or JSX file before the design can be reported as ready",
+      );
+    }
+
     const existingByName = new Map(existingFiles.map((f) => [f.filename, f]));
 
     for (const file of files) {
@@ -270,6 +319,19 @@ export default defineAction({
           agentLeaveDocument(fileId);
         }
 
+        // Update the in-memory map so a second entry with the same filename
+        // in the same `files` array hits the UPDATE branch instead of
+        // inserting a duplicate row.
+        existingByName.set(file.filename, {
+          id: fileId,
+          designId,
+          filename: file.filename,
+          fileType: file.fileType ?? "html",
+          content: file.content,
+          createdAt: now,
+          updatedAt: now,
+        });
+
         savedFiles.push({
           id: fileId,
           filename: file.filename,
@@ -290,31 +352,12 @@ export default defineAction({
     // Merge with existing data so tweak definitions survive content updates.
     // The data column is a free-form JSON blob; we own these keys here and
     // leave anything else intact.
-    const [existingDesign] = await db
-      .select({ data: schema.designs.data })
-      .from(schema.designs)
-      .where(eq(schema.designs.id, designId));
-    let prevData: Record<string, unknown> = {};
-    if (existingDesign?.data) {
-      try {
-        const parsed = JSON.parse(existingDesign.data);
-        if (parsed && typeof parsed === "object") prevData = parsed;
-      } catch {
-        // Stale or invalid JSON — start fresh.
-      }
-    }
-    const mergedData: Record<string, unknown> = {
-      ...prevData,
-      lastPrompt: prompt,
-      generatedAt: now,
-      fileCount: files.length,
-    };
-    if (tweaks !== undefined) {
-      mergedData.tweaks = tweaks.map((tweak) => ({
-        ...tweak,
-        type: tweak.type === "color-swatches" ? "color-swatch" : tweak.type,
-      }));
-    }
+    //
+    // Wrapped in a transaction so that concurrent generate-design calls for the
+    // same design (e.g. the parallel fan-out from generate-screens) each read
+    // the latest canvasFrames and merge their own placement on top, rather than
+    // all reading the same stale snapshot and the last writer silently
+    // discarding the others' frame coordinates.
     let placedFrames:
       | Array<{
           fileId: string;
@@ -322,39 +365,73 @@ export default defineAction({
           frame: CanvasFramePlacement;
         }>
       | undefined;
-    if (canvasFrames !== undefined) {
-      const savedByFileId = new Map(savedFiles.map((file) => [file.id, file]));
-      const savedByFilename = new Map(
-        savedFiles.map((file) => [file.filename, file]),
-      );
-      const existingByFileId = new Map(
-        existingFiles.map((file) => [file.id, file]),
-      );
-      const merged = mergeCanvasFramePlacements({
-        existing: prevData.canvasFrames,
-        placements: canvasFrames,
-        resolveFileId: (placement) => {
-          if (placement.fileId) {
-            return savedByFileId.has(placement.fileId) ||
-              existingByFileId.has(placement.fileId)
-              ? placement.fileId
+    await db.transaction(async (tx) => {
+      const [existingDesign] = await tx
+        .select({ data: schema.designs.data })
+        .from(schema.designs)
+        .where(eq(schema.designs.id, designId));
+      let prevData: Record<string, unknown> = {};
+      if (existingDesign?.data) {
+        try {
+          const parsed = JSON.parse(existingDesign.data);
+          if (parsed && typeof parsed === "object") prevData = parsed;
+        } catch {
+          // Stale or invalid JSON — start fresh.
+        }
+      }
+      const mergedData: Record<string, unknown> = {
+        ...prevData,
+        lastPrompt: prompt,
+        generatedAt: now,
+        fileCount: files.length,
+      };
+      if (tweaks !== undefined) {
+        mergedData.tweaks = tweaks.map((tweak) => ({
+          ...tweak,
+          type: tweak.type === "color-swatches" ? "color-swatch" : tweak.type,
+        }));
+      }
+      if (canvasFrames !== undefined) {
+        const savedByFileId = new Map(
+          savedFiles.map((file) => [file.id, file]),
+        );
+        const savedByFilename = new Map(
+          savedFiles.map((file) => [file.filename, file]),
+        );
+        const existingByFileId = new Map(
+          existingFiles.map((file) => [file.id, file]),
+        );
+        const merged = mergeCanvasFramePlacements({
+          existing: prevData.canvasFrames,
+          placements: canvasFrames,
+          resolveFileId: (placement) => {
+            if (placement.fileId) {
+              return savedByFileId.has(placement.fileId) ||
+                existingByFileId.has(placement.fileId)
+                ? placement.fileId
+                : undefined;
+            }
+            return placement.filename
+              ? (savedByFilename.get(placement.filename)?.id ??
+                  existingByName.get(placement.filename)?.id)
               : undefined;
-          }
-          return placement.filename
-            ? (savedByFilename.get(placement.filename)?.id ??
-                existingByName.get(placement.filename)?.id)
-            : undefined;
-        },
-      });
-      mergedData.canvasFrames = merged.canvasFrames;
-      placedFrames = merged.placedFrames;
-    }
-    designUpdates.data = JSON.stringify(mergedData);
+          },
+        });
+        mergedData.canvasFrames = merged.canvasFrames;
+        placedFrames = merged.placedFrames;
+      }
+      designUpdates.data = JSON.stringify(mergedData);
 
-    await db
-      .update(schema.designs)
-      .set(designUpdates)
-      .where(eq(schema.designs.id, designId));
+      await tx
+        .update(schema.designs)
+        .set(designUpdates)
+        .where(eq(schema.designs.id, designId));
+    });
+
+    await updateGenerationSessionForSavedFiles(
+      designId,
+      savedFiles.map((file) => file.filename),
+    );
 
     return {
       designId,

package/corpus/templates/design/actions/generate-screens.ts

@@ -42,16 +42,27 @@ function designDeepLink(designId: string): string {
   });
 }
 
-const requestedScreenSchema = z.object({
-  frameId: z.string().optional(),
-  title: z.string().min(1),
-  filename: z
-    .string()
-    .optional()
-    .describe("Target filename for this screen, such as onboarding.html"),
-  role: z.enum(["screen", "variant"]).optional().default("screen"),
-  variantOf: z.string().optional(),
-});
+const requestedScreenSchema = z
+  .object({
+    frameId: z.string().optional(),
+    title: z.string().min(1),
+    filename: z
+      .string()
+      .optional()
+      .describe("Target filename for this screen, such as onboarding.html"),
+    role: z.enum(["screen", "variant"]).optional().default("screen"),
+    variantOf: z.string().optional(),
+  })
+  .superRefine((screen, ctx) => {
+    if (screen.role === "variant" && !screen.variantOf) {
+      ctx.addIssue({
+        code: z.ZodIssueCode.custom,
+        path: ["variantOf"],
+        message:
+          "variant screens require variantOf to identify the base screen",
+      });
+    }
+  });
 
 export default defineAction({
   description:
@@ -101,10 +112,39 @@ export default defineAction({
       origin: { x: 0, y: 0 },
       columns: screens.length <= 3 ? screens.length : 3,
     });
+
+    const seenFilenames = new Map<string, number>();
+    // Dedupe any filename (explicit or auto-generated) so two screens can never
+    // resolve to the same target file — otherwise generate-design silently
+    // overwrites the first screen's output with the second's.
+    const dedupeFilename = (base: string): string => {
+      if (!seenFilenames.has(base)) {
+        seenFilenames.set(base, 1);
+        return base;
+      }
+      const count = seenFilenames.get(base)! + 1;
+      seenFilenames.set(base, count);
+      const dot = base.lastIndexOf(".");
+      return dot > 0
+        ? `${base.slice(0, dot)}-${count}${base.slice(dot)}`
+        : `${base}-${count}`;
+    };
+    const requestedTargets = screens.map((screen, index) => {
+      if (screen.filename) return dedupeFilename(screen.filename);
+      const slug =
+        screen.title
+          .toLowerCase()
+          .replace(/[^a-z0-9]+/g, "-")
+          .replace(/^-+|-+$/g, "")
+          .slice(0, 48) || `screen-${index + 1}`;
+      return dedupeFilename(`${slug}.html`);
+    });
+
     const frames: DesignGenerationFrame[] = screens.map((screen, index) => {
       const frameId = screen.frameId ?? nanoid();
       return {
         frameId,
+        filename: requestedTargets[index],
         agentId: `agent-${frameId}`,
         agentName: AGENT_NAMES[index % AGENT_NAMES.length] ?? "Agent",
         agentColor:
@@ -142,15 +182,7 @@ export default defineAction({
 
     const targets = frames.map((frame, index) => {
       const requested = screens[index]!;
-      const filename =
-        requested.filename ??
-        `${
-          requested.title
-            .toLowerCase()
-            .replace(/[^a-z0-9]+/g, "-")
-            .replace(/^-+|-+$/g, "")
-            .slice(0, 48) || `screen-${index + 1}`
-        }.html`;
+      const filename = requestedTargets[index]!;
       return {
         frameId: frame.frameId,
         title: requested.title,

package/corpus/templates/design/actions/get-design-snapshot.ts

@@ -43,7 +43,11 @@ export default defineAction({
   run: async ({ designId }) => {
     const access = await resolveAccess("design", designId);
     if (!access) {
-      throw new Error("Design not found");
+      const err = new Error("Design not found") as Error & {
+        statusCode: number;
+      };
+      err.statusCode = 404;
+      throw err;
     }
     const design = access.resource as typeof schema.designs.$inferSelect;
 

package/corpus/templates/design/actions/get-design.ts

@@ -13,6 +13,7 @@ export default defineAction({
     id: z.string().describe("Design ID"),
   }),
   readOnly: true,
+  requiresAuth: false,
   http: { method: "GET" },
   run: async ({ id }) => {
     const access = await resolveAccess("design", id);
@@ -39,6 +40,7 @@ export default defineAction({
       visibility: row.visibility,
       createdAt: row.createdAt,
       updatedAt: row.updatedAt,
+      accessRole: access.role,
       files: files.map((f) => ({
         id: f.id,
         filename: f.filename,

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

@@ -12,15 +12,28 @@ export default defineAction({
     "has good styling (CSS custom properties, fonts, colors), this extracts those " +
     "into reusable design tokens. Alternatively, import from an existing design system " +
     "for cloning/forking. Returns extracted tokens plus raw CSS for agent refinement.",
-  schema: z.object({
-    designId: z.string().describe("Design project ID to extract tokens from"),
-    designSystemId: z
-      .string()
-      .optional()
-      .describe(
-        "If provided, import from this existing design system instead of extracting from the design project",
-      ),
-  }),
+  schema: z
+    .object({
+      designId: z
+        .string()
+        .optional()
+        .describe("Design project ID to extract tokens from"),
+      designSystemId: z
+        .string()
+        .optional()
+        .describe(
+          "If provided, import from this existing design system instead of extracting from the design project",
+        ),
+    })
+    .superRefine((args, ctx) => {
+      if (!args.designId && !args.designSystemId) {
+        ctx.addIssue({
+          code: z.ZodIssueCode.custom,
+          path: ["designId"],
+          message: "designId or designSystemId is required",
+        });
+      }
+    }),
   readOnly: true,
   http: { method: "GET" },
   run: async ({ designId, designSystemId }) => {
@@ -55,6 +68,12 @@ export default defineAction({
       };
     }
 
+    if (!designId) {
+      throw new Error(
+        "designId is required when designSystemId is not provided",
+      );
+    }
+
     // Extract tokens from the design project
     await assertAccess("design", designId, "viewer");
 

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

@@ -8,6 +8,9 @@ import {
 } from "@agent-native/core/server/design-token-utils";
 import { z } from "zod";
 
+const DOC_MAX_FILES = 20;
+const DOC_MAX_TEXT_BYTES = 500 * 1024;
+
 export default defineAction({
   description:
     "Process uploaded document metadata (DOCX, PPTX, PDF, XLSX) and return " +
@@ -44,16 +47,29 @@ export default defineAction({
   }),
   readOnly: true,
   run: async ({ files }) => {
-    const processedFiles = files.map((file) => {
+    const capped = files.slice(0, DOC_MAX_FILES);
+    const processedFiles = capped.map((file) => {
       const contentType = classifyFile(file.fileType);
-      const hasText = !!file.textContent && file.textContent.trim().length > 0;
+
+      // Truncate textContent before regex scanning to bound CPU/memory usage.
+      let text = file.textContent;
+      if (text) {
+        const encoded = new TextEncoder().encode(text);
+        if (encoded.byteLength > DOC_MAX_TEXT_BYTES) {
+          text = new TextDecoder().decode(
+            encoded.subarray(0, DOC_MAX_TEXT_BYTES),
+          );
+        }
+      }
+
+      const hasText = !!text && text.trim().length > 0;
 
       let likelyColors: string[] = [];
       let likelyFonts: string[] = [];
 
-      if (file.textContent) {
-        likelyColors = extractDocumentColors(file.textContent);
-        likelyFonts = extractDocumentFonts(file.textContent);
+      if (text) {
+        likelyColors = extractDocumentColors(text);
+        likelyFonts = extractDocumentFonts(text);
       }
 
       if (file.metadata) {
@@ -80,9 +96,7 @@ export default defineAction({
           likelyColors,
           likelyFonts,
           contentType,
-          extractedText: file.textContent
-            ? file.textContent.slice(0, 2000)
-            : undefined,
+          extractedText: text ? text.slice(0, 2000) : undefined,
           suggestions,
         },
       };

package/corpus/templates/design/actions/index-design-system-with-builder.ts

@@ -7,11 +7,9 @@ import {
   getRequestOrgId,
   getRequestUserEmail,
 } from "@agent-native/core/server/request-context";
-import { eq } from "drizzle-orm";
-import { nanoid } from "nanoid";
 import { z } from "zod";
 
-import { getDb, schema } from "../server/db/index.js";
+import { upsertBuilderProxyDesignSystem } from "../server/lib/builder-design-system-proxy.js";
 
 const MAX_CODE_FILES = 50;
 const MAX_TOTAL_CODE_BYTES = 2 * 1024 * 1024;
@@ -52,83 +50,6 @@ function makeFiles(
   return files;
 }
 
-function localBuilderDesignSystemId(builderDesignSystemId: string): string {
-  const slug = builderDesignSystemId
-    .replace(/[^a-zA-Z0-9_-]+/g, "-")
-    .replace(/^-+|-+$/g, "")
-    .slice(0, 96);
-  return `builder-${slug || "design-system"}`;
-}
-
-function builderProxyData({
-  builderDesignSystemId,
-  jobId,
-  builderUrl,
-  projectName,
-  description,
-}: {
-  builderDesignSystemId: string;
-  jobId: string;
-  builderUrl: string;
-  projectName?: string;
-  description?: string;
-}) {
-  return JSON.stringify({
-    source: "builder",
-    builderDesignSystemId,
-    builderJobId: jobId,
-    builderUrl,
-    colors: {
-      primary: "var(--primary)",
-      secondary: "var(--secondary)",
-      accent: "var(--accent)",
-      background: "var(--background)",
-      surface: "var(--card)",
-      text: "var(--foreground)",
-      textMuted: "var(--muted-foreground)",
-    },
-    typography: {
-      headingFont: "inherit",
-      bodyFont: "inherit",
-      headingWeight: "700",
-      bodyWeight: "400",
-      headingSizes: { h1: "48px", h2: "32px", h3: "24px" },
-    },
-    spacing: { elementGap: "24px", pagePadding: "48px" },
-    borders: { radius: "12px", accentWidth: "1px" },
-    logos: [],
-    notes: [
-      "This is a local proxy for a Builder-indexed design system.",
-      `Builder design system id: ${builderDesignSystemId}`,
-      `Builder indexing job id: ${jobId}`,
-      `Builder URL: ${builderUrl}`,
-      projectName ? `Requested name: ${projectName}` : "",
-      description ? `Context: ${description}` : "",
-      "Use Builder as the source of truth for extracted tokens and guidance.",
-    ]
-      .filter(Boolean)
-      .join("\n"),
-  });
-}
-
-function builderProxyInstructions({
-  builderDesignSystemId,
-  jobId,
-  builderUrl,
-}: {
-  builderDesignSystemId: string;
-  jobId: string;
-  builderUrl: string;
-}) {
-  return [
-    "This design system is indexed and owned by Builder.",
-    `Builder design system id: ${builderDesignSystemId}`,
-    `Builder job id: ${jobId}`,
-    `Builder URL: ${builderUrl}`,
-    "When generating designs, treat Builder as the source of truth for the final extracted tokens, assets, and guidance.",
-  ].join("\n");
-}
-
 export default defineAction({
   description:
     "Start Builder design-system indexing from a GitHub repository and/or code files. " +
@@ -174,86 +95,18 @@ export default defineAction({
     const ownerEmail = getRequestUserEmail();
     if (!ownerEmail) throw new Error("no authenticated user");
 
-    const db = getDb();
-    const now = new Date().toISOString();
-    const orgId = getRequestOrgId();
-    const baseLocalDesignSystemId = localBuilderDesignSystemId(
-      result.designSystemId,
-    );
-    const title = projectName?.trim() || "Builder indexed design system";
-    const localData = builderProxyData({
-      builderDesignSystemId: result.designSystemId,
-      jobId: result.jobId,
-      builderUrl: result.builderUrl,
+    const proxy = await upsertBuilderProxyDesignSystem({
+      result,
+      ownerEmail,
+      orgId: getRequestOrgId(),
       projectName,
       description,
     });
-    const customInstructions = builderProxyInstructions({
-      builderDesignSystemId: result.designSystemId,
-      jobId: result.jobId,
-      builderUrl: result.builderUrl,
-    });
-    const [existing] = await db
-      .select({
-        id: schema.designSystems.id,
-        ownerEmail: schema.designSystems.ownerEmail,
-      })
-      .from(schema.designSystems)
-      .where(eq(schema.designSystems.id, baseLocalDesignSystemId))
-      .limit(1);
-    const localDesignSystemId =
-      existing && existing.ownerEmail !== ownerEmail
-        ? `${baseLocalDesignSystemId}-${nanoid(8)}`
-        : baseLocalDesignSystemId;
-    if (existing && existing.ownerEmail === ownerEmail) {
-      await db
-        .update(schema.designSystems)
-        .set({
-          title,
-          description:
-            description ??
-            `Builder indexed design system ${result.designSystemId}`,
-          data: localData,
-          assets: "[]",
-          customInstructions,
-          updatedAt: now,
-        })
-        .where(eq(schema.designSystems.id, existing.id));
-    } else {
-      const [ownedSystem] = await db
-        .select({ id: schema.designSystems.id })
-        .from(schema.designSystems)
-        .where(eq(schema.designSystems.ownerEmail, ownerEmail))
-        .limit(1);
-      await db.insert(schema.designSystems).values({
-        id: localDesignSystemId,
-        title,
-        description:
-          description ??
-          `Builder indexed design system ${result.designSystemId}`,
-        data: localData,
-        assets: "[]",
-        customInstructions,
-        isDefault: !ownedSystem,
-        ownerEmail,
-        orgId,
-        createdAt: now,
-        updatedAt: now,
-      });
-    }
 
     return {
       ...result,
-      localDesignSystemId,
+      ...proxy,
       uploadedFileCount: files.length,
-      instructions: [
-        "Builder design-system indexing has started.",
-        `Builder design system: ${result.designSystemId}`,
-        `Local selectable design system: ${localDesignSystemId}`,
-        `Builder job: ${result.jobId}`,
-        `Open: ${result.builderUrl}`,
-        "Use the local design system id in Design flows; Builder remains the source of truth for the indexed brand kit.",
-      ].join("\n"),
     };
   },
 });