@agent-native/core 0.92.6 → 0.92.8

package/corpus/templates/design/actions/open-visual-edit.ts

@@ -34,6 +34,9 @@ const screenRouteSchema = z.object({
   url: z.string().optional(),
   title: z.string().optional(),
   sourceFile: z.string().optional(),
+  sourceKind: z.enum(["react-router", "html", "manual"]).optional(),
+  screenshotUrl: z.string().optional(),
+  metadata: z.record(z.string(), z.unknown()).optional(),
   width: z.number().positive().optional(),
   height: z.number().positive().optional(),
   x: z.number().optional(),
@@ -107,6 +110,11 @@ function routeManifestFromScreens(args: {
   if (screenInputs.length === 0) return undefined;
 
   return screenInputs.map((input) => {
+    if (!input.path && !input.url) {
+      throw new Error(
+        `Route "${input.routeId ?? "(unknown)"}" needs path or url when no routeManifest is provided.`,
+      );
+    }
     const url = routeUrl(args.devServerUrl, {
       path: input.path,
       url: input.url,
@@ -117,7 +125,9 @@ function routeManifestFromScreens(args: {
       path,
       title: input.title ?? titleFromRoutePath(path),
       sourceFile: input.sourceFile,
-      sourceKind: "manual" as const,
+      sourceKind: input.sourceKind ?? ("manual" as const),
+      screenshotUrl: input.screenshotUrl,
+      metadata: input.metadata,
     };
   });
 }
@@ -167,6 +177,12 @@ export default defineAction({
           "returns it as `bridgeToken` so the caller can start the local bridge " +
           "with `design connect --bridge-token <token>`.",
       ),
+    previewToken: z
+      .string()
+      .optional()
+      .describe(
+        "Optional paired read-only preview token from a self-registering CLI. Omit it with bridgeToken to derive the compatible token automatically.",
+      ),
     routes: jsonArray(z.array(screenRouteSchema))
       .optional()
       .describe(
@@ -244,6 +260,7 @@ export default defineAction({
       routeManifest,
       capabilities: args.capabilities,
       bridgeToken: args.bridgeToken,
+      previewToken: args.previewToken,
       status: "connected",
     });
 
@@ -321,6 +338,7 @@ export default defineAction({
       // Minted/stored by connect-localhost; the skill starts the bridge with
       // `design connect --bridge-token <this>` so bridge and row agree.
       bridgeToken: connection.bridgeToken,
+      previewToken: connection.previewToken,
     };
   },
   link: ({ result }) => {

package/corpus/templates/design/actions/present-design-variants.ts

@@ -13,6 +13,7 @@ import { z } from "zod";
 
 import "../server/db/index.js"; // ensure registerShareableResource runs
 import { getDb, schema } from "../server/db/index.js";
+import { mutateDesignData } from "../server/lib/design-data-mutation.js";
 import {
   mergeCanvasFramePlacements,
   type CanvasFramePlacement,
@@ -119,16 +120,6 @@ function isRecord(value: unknown): value is Record<string, unknown> {
   return Boolean(value && typeof value === "object" && !Array.isArray(value));
 }
 
-function parseJsonRecord(value: string | null | undefined) {
-  if (!value) return {};
-  try {
-    const parsed = JSON.parse(value);
-    return isRecord(parsed) ? parsed : {};
-  } catch {
-    return {};
-  }
-}
-
 function slugify(value: string, fallback: string) {
   return (
     value
@@ -472,11 +463,6 @@ export default defineAction({
 
     const db = getDb();
     const now = new Date().toISOString();
-    const [design] = await db
-      .select({ data: schema.designs.data })
-      .from(schema.designs)
-      .where(eq(schema.designs.id, designId))
-      .limit(1);
     const existingFiles = await db
       .select()
       .from(schema.designFiles)
@@ -527,62 +513,76 @@ export default defineAction({
     }
 
     const placements = placeVariantScreens(screens);
-    await db.transaction(async (tx) => {
-      const [currentDesign] = await tx
-        .select({ data: schema.designs.data })
-        .from(schema.designs)
-        .where(eq(schema.designs.id, designId))
-        .limit(1);
-      const prevData = parseJsonRecord(currentDesign?.data ?? design?.data);
-      const mergedFrames = mergeCanvasFramePlacements({
-        existing: prevData.canvasFrames,
-        placements,
-        resolveFileId: (placement) => placement.fileId,
-      });
-      const previousMetadata = isRecord(prevData.screenMetadata)
-        ? { ...prevData.screenMetadata }
-        : {};
-      const previousVariantSets = isRecord(prevData.designVariantSets)
-        ? { ...prevData.designVariantSets }
-        : {};
-      for (const screen of screens) {
-        previousMetadata[screen.id] = {
-          sourceType: "inline",
-          previewState: "preview",
-          title: screen.label,
-          width: screen.width,
-          height: screen.height,
-          variantSetId,
-          variantId: screen.variantId,
+    await mutateDesignData({
+      designId,
+      mutate: (current, { updatedAt }) => {
+        const mergedFrames = mergeCanvasFramePlacements({
+          existing: current.canvasFrames,
+          placements,
+          resolveFileId: (placement) => placement.fileId,
+        });
+        const previousMetadata = isRecord(current.screenMetadata)
+          ? { ...current.screenMetadata }
+          : {};
+        const previousVariantSets = isRecord(current.designVariantSets)
+          ? { ...current.designVariantSets }
+          : {};
+        for (const screen of screens) {
+          previousMetadata[screen.id] = {
+            sourceType: "inline",
+            previewState: "preview",
+            title: screen.label,
+            width: screen.width,
+            height: screen.height,
+            variantSetId,
+            variantId: screen.variantId,
+          };
+        }
+        previousVariantSets[variantSetId] = {
+          id: variantSetId,
+          prompt: prompt ?? "Pick a direction",
+          createdAt: now,
+          screens: screens.map((screen) => ({
+            id: screen.id,
+            variantId: screen.variantId,
+            label: screen.label,
+            filename: screen.filename,
+            width: screen.width,
+            height: screen.height,
+          })),
         };
-      }
-      previousVariantSets[variantSetId] = {
-        id: variantSetId,
-        prompt: prompt ?? "Pick a direction",
-        createdAt: now,
-        screens: screens.map((screen) => ({
-          id: screen.id,
-          variantId: screen.variantId,
-          label: screen.label,
-          filename: screen.filename,
-          width: screen.width,
-          height: screen.height,
-        })),
-      };
-
-      await tx
-        .update(schema.designs)
-        .set({
-          data: JSON.stringify({
-            ...prevData,
-            canvasFrames: mergedFrames.canvasFrames,
-            screenMetadata: previousMetadata,
-            designVariantSets: previousVariantSets,
-            updatedAt: now,
-          }),
-          updatedAt: now,
-        })
-        .where(eq(schema.designs.id, designId));
+
+        return {
+          ...current,
+          canvasFrames: mergedFrames.canvasFrames,
+          screenMetadata: previousMetadata,
+          designVariantSets: previousVariantSets,
+          updatedAt,
+        };
+      },
+      isApplied: (current) => {
+        const canvasFrames = isRecord(current.canvasFrames)
+          ? current.canvasFrames
+          : {};
+        const metadata = isRecord(current.screenMetadata)
+          ? current.screenMetadata
+          : {};
+        const variantSets = isRecord(current.designVariantSets)
+          ? current.designVariantSets
+          : {};
+        const set = isRecord(variantSets[variantSetId])
+          ? variantSets[variantSetId]
+          : null;
+        const persistedScreens = Array.isArray(set?.screens) ? set.screens : [];
+        return screens.every(
+          (screen) =>
+            isRecord(canvasFrames[screen.id]) &&
+            isRecord(metadata[screen.id]) &&
+            persistedScreens.some(
+              (persisted) => isRecord(persisted) && persisted.id === screen.id,
+            ),
+        );
+      },
     });
 
     await writeAppState("navigate", {

package/corpus/templates/design/actions/preview-component-prop-edit.ts

@@ -37,7 +37,7 @@ import {
   componentNodeIdMatches,
   extractProps,
 } from "../shared/component-model.js";
-import { normalizeDesignSourceType } from "../shared/source-mode.js";
+import { designSourceTypeFromData } from "../shared/source-mode.js";
 
 // ─── Helpers ──────────────────────────────────────────────────────────────────
 
@@ -230,19 +230,9 @@ export default defineAction({
       nodeId,
     });
 
-    const sourceType =
-      normalizeDesignSourceType(
-        (() => {
-          try {
-            const d = JSON.parse(
-              (access.resource as { data?: string }).data ?? "{}",
-            ) as Record<string, unknown>;
-            return d.sourceType ?? "inline";
-          } catch {
-            return "inline";
-          }
-        })(),
-      ) ?? "inline";
+    const sourceType = designSourceTypeFromData(
+      (access.resource as { data?: unknown }).data,
+    );
 
     return {
       designId,

package/corpus/templates/design/actions/read-local-file.ts

@@ -15,9 +15,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";
@@ -80,6 +83,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
@@ -92,6 +96,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/remove-breakpoint.ts

@@ -1,48 +1,24 @@
 import { defineAction } from "@agent-native/core";
 import { assertAccess } from "@agent-native/core/sharing";
-import { eq } from "drizzle-orm";
 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 type { BreakpointSet } from "../shared/design-state.js";
 
-function readBreakpointSet(designData: string | null): BreakpointSet | null {
-  if (!designData) return null;
-  try {
-    const parsed = JSON.parse(designData) as Record<string, unknown>;
-    if (parsed.breakpointSet && typeof parsed.breakpointSet === "object") {
-      return parsed.breakpointSet as BreakpointSet;
-    }
-  } catch {
-    // ignore
+function readBreakpointSet(designData: DesignDataRecord): BreakpointSet | null {
+  if (
+    designData.breakpointSet &&
+    typeof designData.breakpointSet === "object"
+  ) {
+    return designData.breakpointSet as BreakpointSet;
   }
   return null;
 }
 
-function writeBreakpointSet(
-  designData: string | null,
-  set: BreakpointSet,
-  now: string,
-): string {
-  let prev: Record<string, unknown> = {};
-  if (designData) {
-    try {
-      const parsed = JSON.parse(designData);
-      if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
-        prev = parsed;
-      }
-    } catch {
-      // ignore
-    }
-  }
-  return JSON.stringify({
-    ...prev,
-    breakpointSet: set,
-    breakpointSetUpdatedAt: now,
-  });
-}
-
 export default defineAction({
   description:
     "Remove a breakpoint frame from the design's breakpoint set by its id. " +
@@ -57,47 +33,50 @@ export default defineAction({
   run: async ({ designId, breakpointId }) => {
     await assertAccess("design", designId, "editor");
 
-    const db = getDb();
-    const [design] = await db
-      .select({ data: schema.designs.data })
-      .from(schema.designs)
-      .where(eq(schema.designs.id, designId))
-      .limit(1);
+    let sawSet = false;
+    let removedBreakpoint: BreakpointSet["breakpoints"][number] | undefined;
+    const persisted = await mutateDesignData({
+      designId,
+      mutate: (current, { updatedAt }) => {
+        const set = readBreakpointSet(current);
+        if (!set) return current;
+        sawSet = true;
+        const removed = set.breakpoints.find((bp) => bp.id === breakpointId);
+        if (!removed) return current;
+        removedBreakpoint = removed;
+        return {
+          ...current,
+          breakpointSet: {
+            ...set,
+            breakpoints: set.breakpoints.filter((bp) => bp.id !== breakpointId),
+          },
+          breakpointSetUpdatedAt: updatedAt,
+        };
+      },
+      isApplied: (current) =>
+        !readBreakpointSet(current)?.breakpoints.some(
+          (breakpoint) => breakpoint.id === breakpointId,
+        ),
+    });
+    const updatedSet = readBreakpointSet(persisted.data);
 
-    if (!design) throw new Error(`Design '${designId}' not found.`);
-
-    const set = readBreakpointSet(design.data);
-    if (!set) {
+    if (!sawSet && !updatedSet) {
       return {
         removed: false,
         reason: "No breakpoint set found for this design.",
       };
     }
-
-    const removed = set.breakpoints.find((bp) => bp.id === breakpointId);
-    if (!removed) {
+    if (!removedBreakpoint) {
       return {
         removed: false,
         reason: `Breakpoint '${breakpointId}' not found in the set.`,
       };
     }
 
-    const updatedSet: BreakpointSet = {
-      ...set,
-      breakpoints: set.breakpoints.filter((bp) => bp.id !== breakpointId),
-    };
-
-    const now = new Date().toISOString();
-    const updatedData = writeBreakpointSet(design.data, updatedSet, now);
-    await db
-      .update(schema.designs)
-      .set({ data: updatedData, updatedAt: now })
-      .where(eq(schema.designs.id, designId));
-
     return {
       removed: true,
-      removedBreakpoint: removed,
-      breakpointSet: updatedSet,
+      removedBreakpoint,
+      breakpointSet: updatedSet!,
     };
   },
 });