@agent-native/core 0.92.7 → 0.92.9

package/corpus/templates/design/actions/grant-localhost-write-consent.ts

@@ -4,7 +4,7 @@ import {
   getRequestUserEmail,
 } from "@agent-native/core/server/request-context";
 import { assertAccess } from "@agent-native/core/sharing";
-import { and, eq } from "drizzle-orm";
+import { and, eq, isNull } from "drizzle-orm";
 import { nanoid } from "nanoid";
 import { z } from "zod";
 
@@ -53,6 +53,9 @@ export default defineAction({
         and(
           eq(schema.designLocalhostConnections.id, connectionId),
           eq(schema.designLocalhostConnections.ownerEmail, ownerEmail),
+          orgId
+            ? eq(schema.designLocalhostConnections.orgId, orgId)
+            : isNull(schema.designLocalhostConnections.orgId),
         ),
       )
       .limit(1);
@@ -93,6 +96,9 @@ export default defineAction({
           eq(schema.designLocalhostWriteGrants.designId, designId),
           eq(schema.designLocalhostWriteGrants.connectionId, connectionId),
           eq(schema.designLocalhostWriteGrants.ownerEmail, ownerEmail),
+          orgId
+            ? eq(schema.designLocalhostWriteGrants.orgId, orgId)
+            : isNull(schema.designLocalhostWriteGrants.orgId),
         ),
       )
       .limit(1);

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

@@ -11,12 +11,17 @@ import {
   extractDocumentColors,
   extractDocumentFonts,
 } from "@agent-native/core/server/design-token-utils";
-import { assertAccess, resolveAccess } from "@agent-native/core/sharing";
+import { assertAccess } from "@agent-native/core/sharing";
 import { eq } from "drizzle-orm";
+import { nanoid } from "nanoid";
 import { z } from "zod";
 
 import { getDb, schema } from "../server/db/index.js";
 import "../server/db/index.js"; // ensure registerShareableResource runs
+import {
+  mutateDesignData,
+  type DesignDataRecord,
+} from "../server/lib/design-data-mutation.js";
 import {
   isSafeCssTokenValue,
   isSafeCssVarName,
@@ -39,6 +44,31 @@ interface ImportedDesignToken {
   source: string;
 }
 
+type TweakDef = Parameters<typeof resolveTweaksToCssVars>[0][number];
+type TweakSelections = Record<string, string | number | boolean>;
+
+function readTweaks(data: DesignDataRecord): TweakDef[] {
+  return Array.isArray(data.tweaks) ? (data.tweaks as TweakDef[]) : [];
+}
+
+function readSelections(data: DesignDataRecord): TweakSelections {
+  return data.tweakSelections &&
+    typeof data.tweakSelections === "object" &&
+    !Array.isArray(data.tweakSelections)
+    ? (data.tweakSelections as TweakSelections)
+    : {};
+}
+
+function selectionKeyForCssVar(tweaks: TweakDef[], cssVar: string): string {
+  return tweaks.find((tweak) => tweak.cssVar === cssVar)?.id ?? cssVar;
+}
+
+function tokenSourceLabel(token: ImportedDesignToken, sourceLabel: string) {
+  return token.source === "CSS variables" || token.source === "Colors"
+    ? sourceLabel
+    : token.source;
+}
+
 const tokenFileSchema = z.object({
   filename: z.string().trim().min(1).describe("File name or relative path"),
   content: z.string().describe("Raw text content"),
@@ -421,85 +451,93 @@ export default defineAction({
       };
     }
 
-    const access = await resolveAccess("design", designId);
-    if (!access) throw new Error("Design not found");
-
-    let prevData: Record<string, unknown> = {};
-    if (access.resource.data) {
-      try {
-        const parsed = JSON.parse(access.resource.data);
-        if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
-          prevData = parsed;
+    const importId = nanoid();
+    const { data: persistedData } = await mutateDesignData({
+      designId,
+      mutate: (prevData, { updatedAt }) => {
+        const tweaks = readTweaks(prevData);
+        const nextSelections = { ...readSelections(prevData) };
+        for (const token of safeTokens) {
+          nextSelections[selectionKeyForCssVar(tweaks, token.cssVar)] =
+            token.value;
         }
-      } catch {
-        // Stale/invalid JSON — preserve the write with a fresh object.
-      }
-    }
 
-    type TweakDef = Parameters<typeof resolveTweaksToCssVars>[0][number];
-    const tweaks: TweakDef[] = Array.isArray(prevData.tweaks)
-      ? (prevData.tweaks as TweakDef[])
-      : [];
-    const cssVarToTweakId = new Map<string, string>();
-    for (const tweak of tweaks) {
-      if (tweak.cssVar) cssVarToTweakId.set(tweak.cssVar, tweak.id);
-    }
-
-    const prevSelections: Record<string, string | number | boolean> =
-      prevData.tweakSelections &&
-      typeof prevData.tweakSelections === "object" &&
-      !Array.isArray(prevData.tweakSelections)
-        ? (prevData.tweakSelections as Record<
-            string,
-            string | number | boolean
-          >)
-        : {};
-    const nextSelections = { ...prevSelections };
-
-    for (const token of safeTokens) {
-      const tweakId = cssVarToTweakId.get(token.cssVar);
-      nextSelections[tweakId ?? token.cssVar] = token.value;
-    }
-
-    const previousSources =
-      prevData.tokenImportSources &&
-      typeof prevData.tokenImportSources === "object" &&
-      !Array.isArray(prevData.tokenImportSources)
-        ? (prevData.tokenImportSources as Record<string, string>)
-        : {};
-    const tokenImportSources = { ...previousSources };
-    for (const token of safeTokens) {
-      tokenImportSources[token.cssVar] =
-        token.source === "CSS variables" || token.source === "Colors"
-          ? sourceLabel
-          : token.source;
-    }
+        const previousSources =
+          prevData.tokenImportSources &&
+          typeof prevData.tokenImportSources === "object" &&
+          !Array.isArray(prevData.tokenImportSources)
+            ? (prevData.tokenImportSources as Record<string, string>)
+            : {};
+        const tokenImportSources = { ...previousSources };
+        for (const token of safeTokens) {
+          tokenImportSources[token.cssVar] = tokenSourceLabel(
+            token,
+            sourceLabel,
+          );
+        }
 
-    const now = new Date().toISOString();
-    const previousImports = Array.isArray(prevData.tokenImports)
-      ? (prevData.tokenImports as unknown[])
-      : [];
-    const nextData: Record<string, unknown> = {
-      ...prevData,
-      tweakSelections: nextSelections,
-      tokenImportSources,
-      tokenImports: [
-        ...previousImports.slice(-9),
-        {
-          source,
-          sourceLabel,
-          tokenCount: safeTokens.length,
-          filesAnalyzed,
-          importedAt: now,
-        },
-      ],
-      tweaksAppliedAt: now,
-    };
+        const previousImports = Array.isArray(prevData.tokenImports)
+          ? (prevData.tokenImports as unknown[])
+          : [];
+        const alreadyAppended = previousImports.some(
+          (entry) =>
+            entry !== null &&
+            typeof entry === "object" &&
+            (entry as { id?: unknown }).id === importId,
+        );
+        const tokenImports = alreadyAppended
+          ? previousImports
+          : [
+              ...previousImports.slice(-9),
+              {
+                id: importId,
+                source,
+                sourceLabel,
+                tokenCount: safeTokens.length,
+                filesAnalyzed,
+                importedAt: updatedAt,
+              },
+            ];
+
+        return {
+          ...prevData,
+          tweakSelections: nextSelections,
+          tokenImportSources,
+          tokenImports,
+          tweaksAppliedAt: updatedAt,
+        };
+      },
+      isApplied: (data) => {
+        const tweaks = readTweaks(data);
+        const selections = readSelections(data);
+        const sources =
+          data.tokenImportSources &&
+          typeof data.tokenImportSources === "object" &&
+          !Array.isArray(data.tokenImportSources)
+            ? (data.tokenImportSources as Record<string, string>)
+            : {};
+        const imports = Array.isArray(data.tokenImports)
+          ? data.tokenImports
+          : [];
+        return (
+          safeTokens.every(
+            (token) =>
+              selections[selectionKeyForCssVar(tweaks, token.cssVar)] ===
+                token.value &&
+              sources[token.cssVar] === tokenSourceLabel(token, sourceLabel),
+          ) &&
+          imports.some(
+            (entry) =>
+              entry !== null &&
+              typeof entry === "object" &&
+              (entry as { id?: unknown }).id === importId,
+          )
+        );
+      },
+    });
 
-    await db
-      .update(schema.designs)
-      .set({ data: JSON.stringify(nextData), updatedAt: now })
-      .where(eq(schema.designs.id, designId));
+    const tweaks = readTweaks(persistedData);
+    const nextSelections = readSelections(persistedData);
 
     return {
       designId,

package/corpus/templates/design/actions/index-components.ts

@@ -34,7 +34,7 @@ import {
   type ComponentInstance,
 } from "../shared/component-model.js";
 import { hasCapability } from "../shared/design-source-capabilities.js";
-import { normalizeDesignSourceType } from "../shared/source-mode.js";
+import { designSourceTypeFromData } from "../shared/source-mode.js";
 
 // ─── Helpers ──────────────────────────────────────────────────────────────────
 
@@ -89,24 +89,8 @@ export default defineAction({
     const access = await assertAccess("design", designId, "editor");
 
     // ── Source type + capability check ──────────────────────────────────────
-    let rawSourceType: unknown = "inline";
     const rawData = (access.resource as { data?: unknown }).data;
-    if (typeof rawData === "string") {
-      try {
-        const parsed: unknown = JSON.parse(rawData);
-        if (
-          parsed !== null &&
-          typeof parsed === "object" &&
-          "sourceType" in (parsed as object)
-        ) {
-          rawSourceType = (parsed as { sourceType: unknown }).sourceType;
-        }
-      } catch {
-        // Stale JSON — default to inline.
-      }
-    }
-
-    const sourceType = normalizeDesignSourceType(rawSourceType) ?? "inline";
+    const sourceType = designSourceTypeFromData(rawData);
     const caps = resolveSourceCapabilities(sourceType);
 
     // Real-app sources gate on `indexComponents`.  For inline designs this

package/corpus/templates/design/actions/list-design-source-capabilities.ts

@@ -1,13 +1,20 @@
 import { defineAction } from "@agent-native/core";
+import {
+  getRequestOrgId,
+  getRequestUserEmail,
+} from "@agent-native/core/server/request-context";
 import { resolveAccess } from "@agent-native/core/sharing";
-import { eq } from "drizzle-orm";
+import { and, eq, isNull } from "drizzle-orm";
 import { z } from "zod";
 
 import { getDb, schema } from "../server/db/index.js";
 import { resolveSourceCapabilities } from "../shared/capability-resolver.js";
 import { DESIGN_CAPABILITY_NAMES } from "../shared/design-source-capabilities.js";
 import "../server/db/index.js"; // ensure registerShareableResource runs
-import { normalizeDesignSourceType } from "../shared/source-mode.js";
+import {
+  designConnectionIdFromData,
+  designSourceTypeFromData,
+} from "../shared/source-mode.js";
 
 export default defineAction({
   description:
@@ -36,25 +43,8 @@ export default defineAction({
     // Resolve source type from the design's data blob.  The `sourceType`
     // field lives inside `designs.data` as a JSON key (set by connect-localhost
     // and the fusion upgrade flow), falling back to "inline" when absent.
-    let rawSourceType: unknown = "inline";
     const rawData = (access.resource as { data?: unknown }).data;
-    if (typeof rawData === "string") {
-      try {
-        const parsed: unknown = JSON.parse(rawData);
-        if (
-          parsed !== null &&
-          typeof parsed === "object" &&
-          !Array.isArray(parsed) &&
-          "sourceType" in (parsed as object)
-        ) {
-          rawSourceType = (parsed as { sourceType: unknown }).sourceType;
-        }
-      } catch {
-        // Stale/invalid JSON — default to "inline".
-      }
-    }
-
-    const sourceType = normalizeDesignSourceType(rawSourceType) ?? "inline";
+    const sourceType = designSourceTypeFromData(rawData);
     const capabilities = resolveSourceCapabilities(sourceType);
 
     // Collect active localhost capabilities from the design's stored connection,
@@ -65,20 +55,25 @@ export default defineAction({
       try {
         const rawDesignData =
           typeof rawData === "string" ? JSON.parse(rawData) : {};
-        const connectionId =
-          typeof rawDesignData === "object" &&
-          rawDesignData !== null &&
-          "connectionId" in rawDesignData
-            ? String(rawDesignData.connectionId)
-            : undefined;
+        const connectionId = designConnectionIdFromData(rawDesignData);
 
-        if (connectionId) {
+        const ownerEmail = getRequestUserEmail();
+        const orgId = getRequestOrgId() ?? null;
+        if (connectionId && ownerEmail) {
           const [conn] = await db
             .select({
               capabilities: schema.designLocalhostConnections.capabilities,
             })
             .from(schema.designLocalhostConnections)
-            .where(eq(schema.designLocalhostConnections.id, connectionId))
+            .where(
+              and(
+                eq(schema.designLocalhostConnections.id, connectionId),
+                eq(schema.designLocalhostConnections.ownerEmail, ownerEmail),
+                orgId
+                  ? eq(schema.designLocalhostConnections.orgId, orgId)
+                  : isNull(schema.designLocalhostConnections.orgId),
+              ),
+            )
             .limit(1);
 
           if (conn?.capabilities) {

package/corpus/templates/design/actions/list-local-files.ts

@@ -13,9 +13,12 @@
  */
 
 import { defineAction } from "@agent-native/core";
-import { getRequestUserEmail } from "@agent-native/core/server/request-context";
+import {
+  getRequestOrgId,
+  getRequestUserEmail,
+} from "@agent-native/core/server/request-context";
 import { assertAccess } from "@agent-native/core/sharing";
-import { and, eq } from "drizzle-orm";
+import { and, eq, isNull } from "drizzle-orm";
 import { z } from "zod";
 
 import { getDb, schema } from "../server/db/index.js";
@@ -76,6 +79,7 @@ export default defineAction({
 
     const ownerEmail = getRequestUserEmail();
     if (!ownerEmail) throw new Error("no authenticated user");
+    const orgId = getRequestOrgId() ?? null;
 
     const db = getDb();
     const [connection] = await db
@@ -88,6 +92,9 @@ export default defineAction({
         and(
           eq(schema.designLocalhostConnections.id, connectionId),
           eq(schema.designLocalhostConnections.ownerEmail, ownerEmail),
+          orgId
+            ? eq(schema.designLocalhostConnections.orgId, orgId)
+            : isNull(schema.designLocalhostConnections.orgId),
         ),
       )
       .limit(1);

package/corpus/templates/design/actions/migrate-board-objects-to-file.ts

@@ -13,8 +13,8 @@
  *    coordinates exactly (no clamping).
  * 3. Inserts the fragments as direct <body> children of a new __board__.html
  *    design file (or merges into an existing one if somehow already present).
- * 4. Stores the new file's id into designs.data.boardFileId in a transaction.
- * 5. Nulls out designs.data.boardObjects so the old model no longer conflicts.
+ * 4. Reserves one stable file id in designs.data, then upserts the board file.
+ * 5. Finalizes boardFileId and nulls boardObjects through a retryable mutation.
  *
  * ## Contract
  *
@@ -37,6 +37,7 @@ import { nanoid } from "nanoid";
 import { z } from "zod";
 
 import { getDb, schema } from "../server/db/index.js";
+import { mutateDesignData } from "../server/lib/design-data-mutation.js";
 import {
   BOARD_FILENAME,
   backfillBoardPrimitiveMarkers,
@@ -64,29 +65,39 @@ export default defineAction({
     const db = getDb();
 
     // ── 1. Idempotency guard ──────────────────────────────────────────────
-    // Read the design data JSON to check whether boardFileId is already set.
-    // guard:allow-unscoped — assertAccess "editor" above scopes this read to
-    // the requesting user's accessible designs.
-    const [existing] = await db
-      .select({ data: schema.designs.data })
-      .from(schema.designs)
-      .where(eq(schema.designs.id, designId))
+    // Reserve one stable file id without clearing boardObjects. If the process
+    // stops between phases, the next call resumes the same reservation.
+    const [preexistingBoardFile] = await db
+      .select({ id: schema.designFiles.id })
+      .from(schema.designFiles)
+      .where(
+        and(
+          eq(schema.designFiles.designId, designId),
+          eq(schema.designFiles.filename, BOARD_FILENAME),
+        ),
+      )
       .limit(1);
-
-    if (!existing) {
-      throw new Error(`Design "${designId}" not found.`);
-    }
-
-    let parsed: Record<string, unknown>;
-    try {
-      const raw = JSON.parse(existing.data);
-      parsed =
-        raw && typeof raw === "object" && !Array.isArray(raw)
-          ? (raw as Record<string, unknown>)
-          : {};
-    } catch {
-      parsed = {};
-    }
+    const proposedBoardFileId = preexistingBoardFile?.id ?? nanoid();
+    const reservation = await mutateDesignData({
+      designId,
+      mutate: (current) => {
+        if (
+          (typeof current.boardFileId === "string" && current.boardFileId) ||
+          (typeof current.boardFileMigrationId === "string" &&
+            current.boardFileMigrationId)
+        ) {
+          return current;
+        }
+        return { ...current, boardFileMigrationId: proposedBoardFileId };
+      },
+      isApplied: (current) =>
+        Boolean(
+          (typeof current.boardFileId === "string" && current.boardFileId) ||
+          (typeof current.boardFileMigrationId === "string" &&
+            current.boardFileMigrationId),
+        ),
+    });
+    const parsed = reservation.data;
 
     if (
       typeof parsed["boardFileId"] === "string" &&
@@ -176,68 +187,32 @@ export default defineAction({
 
     const now = new Date().toISOString();
 
-    // ── 4. Upsert the board file and update designs.data atomically ───────
-    // Run in a transaction so concurrent opens cannot create two board files.
-    let boardFileId = "";
-
-    await db.transaction(async (tx) => {
-      // Re-read designs.data inside the transaction to guard against a
-      // concurrent migration that raced us.
-      const [fresh] = await tx
-        .select({ data: schema.designs.data })
-        .from(schema.designs)
-        .where(eq(schema.designs.id, designId))
-        .limit(1);
-
-      if (!fresh) {
-        throw new Error(`Design "${designId}" not found.`);
-      }
+    // ── 4. Upsert the board file, then finalize the reservation ────────
+    const reservationId =
+      typeof parsed.boardFileMigrationId === "string" &&
+      parsed.boardFileMigrationId
+        ? parsed.boardFileMigrationId
+        : proposedBoardFileId;
+    const [existingBoardFile] = await db
+      .select({ id: schema.designFiles.id })
+      .from(schema.designFiles)
+      .where(
+        and(
+          eq(schema.designFiles.designId, designId),
+          eq(schema.designFiles.filename, BOARD_FILENAME),
+        ),
+      )
+      .limit(1);
+    const boardFileId = existingBoardFile?.id ?? reservationId;
 
-      let freshParsed: Record<string, unknown>;
+    if (existingBoardFile) {
+      await db
+        .update(schema.designFiles)
+        .set({ content: boardHtml, updatedAt: now })
+        .where(eq(schema.designFiles.id, boardFileId));
+    } else {
       try {
-        const raw = JSON.parse(fresh.data);
-        freshParsed =
-          raw && typeof raw === "object" && !Array.isArray(raw)
-            ? (raw as Record<string, unknown>)
-            : {};
-      } catch {
-        freshParsed = {};
-      }
-
-      // Double-check inside the transaction.
-      if (
-        typeof freshParsed["boardFileId"] === "string" &&
-        freshParsed["boardFileId"].length > 0
-      ) {
-        boardFileId = freshParsed["boardFileId"] as string;
-        return; // Another concurrent call already finished — skip.
-      }
-
-      // Check if a __board__.html file was somehow already created (shouldn't
-      // happen in normal flow, but be defensive).
-      const [existingBoardFile] = await tx
-        .select({ id: schema.designFiles.id })
-        .from(schema.designFiles)
-        .where(
-          and(
-            eq(schema.designFiles.designId, designId),
-            eq(schema.designFiles.filename, BOARD_FILENAME),
-          ),
-        )
-        .limit(1);
-
-      if (existingBoardFile) {
-        // Board file exists but boardFileId was not set — link it and update
-        // its content.
-        boardFileId = existingBoardFile.id;
-        await tx
-          .update(schema.designFiles)
-          .set({ content: boardHtml, updatedAt: now })
-          .where(eq(schema.designFiles.id, boardFileId));
-      } else {
-        // Create the board file.
-        boardFileId = nanoid();
-        await tx.insert(schema.designFiles).values({
+        await db.insert(schema.designFiles).values({
           id: boardFileId,
           designId,
           filename: BOARD_FILENAME,
@@ -246,22 +221,31 @@ export default defineAction({
           createdAt: now,
           updatedAt: now,
         });
+      } catch (error) {
+        const [concurrentBoardFile] = await db
+          .select({ id: schema.designFiles.id })
+          .from(schema.designFiles)
+          .where(eq(schema.designFiles.id, boardFileId))
+          .limit(1);
+        if (!concurrentBoardFile) throw error;
       }
+    }
 
-      // Write boardFileId into designs.data; null out boardObjects.
-      const nextData: Record<string, unknown> = {
-        ...freshParsed,
-        boardFileId,
-        boardObjects: null,
-      };
-
-      await tx
-        .update(schema.designs)
-        .set({
-          data: JSON.stringify(nextData),
-          updatedAt: now,
-        })
-        .where(eq(schema.designs.id, designId));
+    await mutateDesignData({
+      designId,
+      mutate: (current) => {
+        if (typeof current.boardFileId === "string" && current.boardFileId) {
+          return current;
+        }
+        const next: Record<string, unknown> = {
+          ...current,
+          boardFileId,
+          boardObjects: null,
+        };
+        delete next.boardFileMigrationId;
+        return next;
+      },
+      isApplied: (current) => current.boardFileId === boardFileId,
     });
 
     // ── 5. Seed collab state for the new board file ───────────────────────

package/corpus/templates/design/actions/open-component-source.ts

@@ -41,7 +41,7 @@ import {
   componentNodeIdMatches,
 } from "../shared/component-model.js";
 import { hasCapability } from "../shared/design-source-capabilities.js";
-import { normalizeDesignSourceType } from "../shared/source-mode.js";
+import { designSourceTypeFromData } from "../shared/source-mode.js";
 
 // ─── Helpers ──────────────────────────────────────────────────────────────────
 
@@ -90,24 +90,8 @@ export default defineAction({
     if (!access) throw new Error("Design not found");
 
     // ── Source type + capabilities ───────────────────────────────────────────
-    let rawSourceType: unknown = "inline";
     const rawData = (access.resource as { data?: unknown }).data;
-    if (typeof rawData === "string") {
-      try {
-        const parsed: unknown = JSON.parse(rawData);
-        if (
-          parsed !== null &&
-          typeof parsed === "object" &&
-          "sourceType" in (parsed as object)
-        ) {
-          rawSourceType = (parsed as { sourceType: unknown }).sourceType;
-        }
-      } catch {
-        // Default to inline.
-      }
-    }
-
-    const sourceType = normalizeDesignSourceType(rawSourceType) ?? "inline";
+    const sourceType = designSourceTypeFromData(rawData);
     const caps = resolveSourceCapabilities(sourceType);
     const canResolveToFile = hasCapability(caps, "resolveNodeToFile");