@agent-native/core 0.80.4 → 0.80.6

package/corpus/templates/design/actions/create-design-system.ts

@@ -3,7 +3,7 @@ import {
   getRequestUserEmail,
   getRequestOrgId,
 } from "@agent-native/core/server/request-context";
-import { eq } from "drizzle-orm";
+import { and, eq, isNull } from "drizzle-orm";
 import { nanoid } from "nanoid";
 import { z } from "zod";
 
@@ -66,12 +66,23 @@ export default defineAction({
     if (!ownerEmail) throw new Error("no authenticated user");
     const orgId = getRequestOrgId();
 
-    // Check only this user's owned systems. Shared systems should not prevent
-    // the first system a user creates from becoming their default.
+    // Check only this user's owned systems within the same org. Shared systems
+    // should not prevent the first system a user creates from becoming their
+    // default, and systems in other orgs must not suppress the default in this org.
     const existing = await db
       .select({ id: schema.designSystems.id })
       .from(schema.designSystems)
-      .where(eq(schema.designSystems.ownerEmail, ownerEmail))
+      .where(
+        orgId
+          ? and(
+              eq(schema.designSystems.ownerEmail, ownerEmail),
+              eq(schema.designSystems.orgId, orgId),
+            )
+          : and(
+              eq(schema.designSystems.ownerEmail, ownerEmail),
+              isNull(schema.designSystems.orgId),
+            ),
+      )
       .limit(1);
 
     const isDefault = existing.length === 0;

package/corpus/templates/design/actions/create-file.ts

@@ -1,7 +1,7 @@
 import { defineAction } from "@agent-native/core";
 import { seedFromText } from "@agent-native/core/collab";
 import { assertAccess } from "@agent-native/core/sharing";
-import { eq } from "drizzle-orm";
+import { and, eq } from "drizzle-orm";
 import { nanoid } from "nanoid";
 import { z } from "zod";
 
@@ -34,6 +34,25 @@ export default defineAction({
     await assertAccess("design", designId, "editor");
 
     const db = getDb();
+
+    // Guard against duplicate (designId, filename) — edit-design uses .limit(1)
+    // which is non-deterministic when multiple rows match the same key.
+    const [existing] = await db
+      .select({ id: schema.designFiles.id })
+      .from(schema.designFiles)
+      .where(
+        and(
+          eq(schema.designFiles.designId, designId),
+          eq(schema.designFiles.filename, filename),
+        ),
+      )
+      .limit(1);
+    if (existing) {
+      throw new Error(
+        `File "${filename}" already exists in design ${designId} — use edit-design to modify it`,
+      );
+    }
+
     const id = nanoid();
     const now = new Date().toISOString();
 

package/corpus/templates/design/actions/delete-design-system.ts

@@ -7,12 +7,12 @@ import { getDb, schema } from "../server/db/index.js";
 
 export default defineAction({
   description:
-    "Delete a design system. Requires admin access. Designs linked to it are unlinked.",
+    "Delete a design system. Requires owner access. Designs linked to it are unlinked.",
   schema: z.object({
     id: z.string().min(1).describe("Design system ID to delete"),
   }),
   run: async ({ id }) => {
-    await assertAccess("design-system", id, "admin");
+    await assertAccess("design-system", id, "owner");
 
     const db = getDb();
 

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

@@ -31,14 +31,45 @@ export default defineAction({
     const now = new Date().toISOString();
     const newTitle = title || `Copy of ${source.title}`;
 
-    // Copy the design
+    // Fetch source files first so we can remap canvasFrames before inserting
+    const files = await db
+      .select()
+      .from(schema.designFiles)
+      .where(eq(schema.designFiles.designId, id));
+
+    // Build old-to-new file ID mapping upfront
+    const idMap = new Map<string, string>(
+      files.map((file) => [file.id, nanoid()]),
+    );
+
+    // Remap canvasFrames keys in source.data from old IDs to new IDs
+    let newData = source.data;
+    try {
+      const parsed =
+        typeof source.data === "string" ? JSON.parse(source.data) : source.data;
+      if (parsed && typeof parsed === "object" && parsed.canvasFrames) {
+        const remapped: Record<string, unknown> = {};
+        for (const [oldId, geometry] of Object.entries(parsed.canvasFrames)) {
+          const newFileId = idMap.get(oldId);
+          remapped[newFileId ?? oldId] = geometry;
+        }
+        newData =
+          typeof source.data === "string"
+            ? JSON.stringify({ ...parsed, canvasFrames: remapped })
+            : { ...parsed, canvasFrames: remapped };
+      }
+    } catch {
+      // If data is unparseable, fall back to copying verbatim
+    }
+
+    // Copy the design with remapped canvasFrames
     await db.insert(schema.designs).values({
       id: newId,
       title: newTitle,
       description: source.description,
       projectType: source.projectType,
       designSystemId: source.designSystemId ?? null,
-      data: source.data,
+      data: newData,
       ownerEmail: (() => {
         const e = getRequestUserEmail();
         if (!e) throw new Error("no authenticated user");
@@ -49,15 +80,10 @@ export default defineAction({
       updatedAt: now,
     });
 
-    // Copy all associated files with new IDs
-    const files = await db
-      .select()
-      .from(schema.designFiles)
-      .where(eq(schema.designFiles.designId, id));
-
+    // Copy all associated files using the pre-generated IDs
     for (const file of files) {
       await db.insert(schema.designFiles).values({
-        id: nanoid(),
+        id: idMap.get(file.id)!,
         designId: newId,
         filename: file.filename,
         fileType: file.fileType,

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,
         },
       };