@agent-native/core 0.85.7 → 0.86.0

package/corpus/templates/design/actions/send-fusion-message.ts

@@ -0,0 +1,69 @@
+/**
+ * send-fusion-message — relay a freeform prompt to the fusion app's
+ * in-container coding agent.
+ *
+ * This is how the Design agent hands off user requests that go beyond
+ * discrete queued visual edits — e.g. "add a new page", "wire up this API",
+ * "fix this bug" — to the app's own coding agent for fusion-backed designs.
+ * Unlike queue-fusion-edit/apply-fusion-edits (which batch small visual
+ * tweaks), this sends immediately and does not persist a design_fusion_edits
+ * row.
+ */
+
+import { defineAction } from "@agent-native/core";
+import { sendFusionBranchMessage } from "@agent-native/core/server";
+import { getRequestUserEmail } from "@agent-native/core/server/request-context";
+import { assertAccess } from "@agent-native/core/sharing";
+import { z } from "zod";
+
+import { schema } from "../server/db/index.js";
+import "../server/db/index.js"; // ensure registerShareableResource runs
+import {
+  FULL_APP_BUILDING_ENABLED,
+  readFusionApp,
+} from "../shared/full-app.js";
+
+export default defineAction({
+  description:
+    "Send a freeform natural-language prompt directly to a fusion (full-app) " +
+    "design's in-container coding agent. Use this to relay user requests that " +
+    "are broader than a single visual tweak (new features, pages, data model " +
+    "changes, bug fixes) for designs backed by a running app container. For " +
+    "small scoped visual edits on a specific screen/element, prefer " +
+    "queue-fusion-edit + apply-fusion-edits instead so edits can be batched.",
+  schema: z.object({
+    designId: z.string().describe("Design project ID backed by a fusion app."),
+    prompt: z
+      .string()
+      .min(1)
+      .describe("The message to send to the app's coding agent."),
+  }),
+  run: async ({ designId, prompt }) => {
+    if (!FULL_APP_BUILDING_ENABLED) {
+      throw new Error("Full app building is not enabled");
+    }
+
+    const access = await assertAccess("design", designId, "editor");
+    const design = access.resource as typeof schema.designs.$inferSelect;
+    const fusionApp = readFusionApp(design.data);
+    if (!fusionApp) {
+      throw new Error(
+        "This design has no fusion app linkage. Call create-fusion-app first.",
+      );
+    }
+
+    const ownerEmail = getRequestUserEmail();
+    const result = await sendFusionBranchMessage({
+      projectId: fusionApp.projectId,
+      branchName: fusionApp.branchName,
+      prompt,
+      userEmail: ownerEmail ?? undefined,
+    });
+
+    return {
+      sent: result.sent,
+      message: result.response,
+      error: result.error,
+    };
+  },
+});

package/corpus/templates/design/actions/sync-fusion-app.ts

@@ -0,0 +1,196 @@
+/**
+ * sync-fusion-app — poll/attach the fusion branch container and refresh the
+ * design's URL-backed screens once it is ready.
+ *
+ * This is the follow-up to `create-fusion-app`: the branch container may take
+ * a while to boot, so callers poll this action until `status: "ready"`. Once
+ * ready, it upserts URL-backed screens for the given (or previously placed)
+ * paths pointing at the container's dev-server preview URL, so the canvas can
+ * render them as live iframes.
+ */
+
+import { defineAction } from "@agent-native/core";
+import { ensureFusionContainer } from "@agent-native/core/server";
+import { assertAccess } from "@agent-native/core/sharing";
+import { and, count, 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 {
+  DEFAULT_FUSION_SCREEN_HEIGHT,
+  DEFAULT_FUSION_SCREEN_WIDTH,
+  upsertFusionScreens,
+} from "../server/lib/fusion-screens.js";
+import {
+  FULL_APP_BUILDING_ENABLED,
+  parseDesignDataBlob,
+  readFusionApp,
+  writeFusionApp,
+} from "../shared/full-app.js";
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return Boolean(value && typeof value === "object" && !Array.isArray(value));
+}
+
+async function countPendingEdits(
+  design: Pick<typeof schema.designs.$inferSelect, "id" | "ownerEmail">,
+): Promise<number> {
+  const db = getDb();
+  const [row] = await db
+    .select({ value: count() })
+    .from(schema.designFusionEdits)
+    .where(
+      and(
+        eq(schema.designFusionEdits.designId, design.id),
+        eq(schema.designFusionEdits.ownerEmail, design.ownerEmail),
+        eq(schema.designFusionEdits.status, "pending"),
+      ),
+    );
+  return row?.value ?? 0;
+}
+
+export default defineAction({
+  description:
+    "Poll the fusion app's container status and refresh its URL-backed " +
+    "screens once ready. Call this after create-fusion-app (or periodically " +
+    "while status is 'building') to pick up the live preview URL. When ready, " +
+    "upserts screens for the given paths (or the design's existing fusion " +
+    "screens, defaulting to '/') so the canvas iframes point at the live " +
+    "container. Returns pendingEditCount so the caller knows whether queued " +
+    "edits are waiting to be applied.",
+  schema: z.object({
+    designId: z.string().describe("Design project ID backed by a fusion app."),
+    paths: z
+      .array(z.string())
+      .optional()
+      .describe(
+        "Route paths to place/refresh as screens (e.g. ['/', '/settings']). " +
+          "Defaults to the design's existing fusion screen paths, or ['/'] if none exist.",
+      ),
+  }),
+  run: async ({ designId, paths }) => {
+    if (!FULL_APP_BUILDING_ENABLED) {
+      throw new Error("Full app building is not enabled");
+    }
+
+    const access = await assertAccess("design", designId, "editor");
+    const design = access.resource as typeof schema.designs.$inferSelect;
+    const data = parseDesignDataBlob(design.data);
+    const fusionApp = readFusionApp(data);
+    if (!fusionApp) {
+      throw new Error(
+        "This design has no fusion app linkage. Call create-fusion-app first.",
+      );
+    }
+
+    const result = await ensureFusionContainer({
+      projectId: fusionApp.projectId,
+      branchName: fusionApp.branchName,
+      timeoutMs: 20_000,
+    });
+
+    const db = getDb();
+    const now = new Date().toISOString();
+
+    if (result.status === "error") {
+      const nextData = writeFusionApp(data, {
+        ...fusionApp,
+        status: "error",
+        statusMessage: result.message ?? "Container provisioning failed",
+        updatedAt: now,
+      });
+      await db
+        .update(schema.designs)
+        .set({ data: JSON.stringify(nextData), updatedAt: now })
+        .where(eq(schema.designs.id, designId));
+      return {
+        status: "error" as const,
+        message: result.message ?? "Container provisioning failed",
+      };
+    }
+
+    if (result.status === "provisioning") {
+      const nextData = writeFusionApp(data, {
+        ...fusionApp,
+        status: "building",
+        statusMessage: result.message ?? "Container is still starting",
+        updatedAt: now,
+      });
+      await db
+        .update(schema.designs)
+        .set({ data: JSON.stringify(nextData), updatedAt: now })
+        .where(eq(schema.designs.id, designId));
+      return {
+        status: "building" as const,
+        message: result.message ?? "Container is still starting",
+      };
+    }
+
+    // ready
+    const previewUrl = result.url;
+    if (!previewUrl) {
+      throw new Error("Container reported ready but returned no preview URL");
+    }
+
+    const existingScreenMetadata = isRecord(data.screenMetadata)
+      ? (data.screenMetadata as Record<string, unknown>)
+      : {};
+    const existingFusionPaths = Object.values(existingScreenMetadata)
+      .filter(
+        (entry): entry is Record<string, unknown> =>
+          isRecord(entry) && entry.sourceType === "fusion",
+      )
+      .map((entry) => (typeof entry.path === "string" ? entry.path : undefined))
+      .filter((path): path is string => Boolean(path));
+
+    const effectivePaths =
+      paths && paths.length > 0
+        ? paths
+        : existingFusionPaths.length > 0
+          ? existingFusionPaths
+          : ["/"];
+
+    const { screens } = await upsertFusionScreens({
+      designId,
+      previewUrl,
+      paths: effectivePaths,
+      width: DEFAULT_FUSION_SCREEN_WIDTH,
+      height: DEFAULT_FUSION_SCREEN_HEIGHT,
+    });
+
+    // Re-read the design's data since upsertFusionScreens just wrote it, then
+    // layer the fusionApp update on top so we don't clobber the screen writes.
+    const [refreshed] = await db
+      .select({ data: schema.designs.data })
+      .from(schema.designs)
+      .where(eq(schema.designs.id, designId))
+      .limit(1);
+    const refreshedData = parseDesignDataBlob(refreshed?.data);
+    const nextData = writeFusionApp(refreshedData, {
+      ...fusionApp,
+      previewUrl,
+      status: "ready",
+      statusMessage: result.message ?? "Container is ready",
+      updatedAt: now,
+    });
+    await db
+      .update(schema.designs)
+      .set({ data: JSON.stringify(nextData), updatedAt: now })
+      .where(eq(schema.designs.id, designId));
+
+    const pendingEditCount = await countPendingEdits(design);
+
+    return {
+      status: "ready" as const,
+      previewUrl,
+      screens: screens.map((screen) => ({
+        fileId: screen.fileId,
+        path: screen.path,
+        url: screen.url,
+        title: screen.title,
+      })),
+      pendingEditCount,
+    };
+  },
+});

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

@@ -29,15 +29,66 @@ import { z } from "zod";
 import { getDb, schema } from "../server/db/index.js";
 import { verifyWriteGrant } from "../server/lib/verify-write-grant.js";
 
-/** File extensions the agent is permitted to write via the bridge. */
-const ALLOWED_EXTENSIONS = new Set([".html", ".htm", ".css"]);
+/**
+ * Text/code file extensions the agent is permitted to write via the bridge.
+ * Mirrors ALLOWED_WRITE_EXTENSIONS in the core design-connect bridge, which
+ * enforces the same list plus a secret-path blocklist on its side.
+ */
+const ALLOWED_EXTENSIONS = new Set([
+  ".html",
+  ".htm",
+  ".css",
+  ".scss",
+  ".less",
+  ".js",
+  ".jsx",
+  ".ts",
+  ".tsx",
+  ".mjs",
+  ".cjs",
+  ".json",
+  ".md",
+  ".mdx",
+  ".vue",
+  ".svelte",
+  ".astro",
+  ".txt",
+  ".yml",
+  ".yaml",
+  ".svg",
+]);
+
+/**
+ * Secret-looking paths are never writable, regardless of extension. All
+ * comparisons are case-insensitive: macOS's default filesystem (and Windows)
+ * is case-insensitive, so ".ENV", "ID_RSA", or "KEY.PEM" refer to the exact
+ * same on-disk file as their lowercase form and must be blocked identically.
+ * Mirrors isBlockedSecretPath in packages/core/src/cli/design-connect.ts.
+ */
+function isBlockedSecretPath(relPath: string): boolean {
+  const segments = relPath
+    .split(/[\\/]+/)
+    .filter(Boolean)
+    .map((segment) => segment.toLowerCase());
+  const basename = segments[segments.length - 1] ?? "";
+  if (segments.some((segment) => segment === ".git")) return true;
+  if (basename.startsWith(".env")) return true;
+  if (basename.endsWith(".pem") || basename.endsWith(".key")) return true;
+  if (basename.startsWith("id_rsa")) return true;
+  return false;
+}
 
 function assertAllowedExtension(relPath: string): void {
+  if (isBlockedSecretPath(relPath)) {
+    throw new Error(
+      `File "${relPath}" looks like a secret or VCS-internal file and may not be written through the bridge.`,
+    );
+  }
   const ext = path.extname(relPath).toLowerCase();
   if (!ALLOWED_EXTENSIONS.has(ext)) {
     throw new Error(
       `File "${relPath}" has extension "${ext}" which is not allowed. ` +
-        "Only .html, .htm, and .css files may be written through the bridge.",
+        "Only text and code files (HTML, CSS, JS/TS, JSON, Markdown, and similar) may be written through the bridge.",
     );
   }
 }
@@ -105,11 +156,14 @@ function normalizeBridgeUrl(value: string): string {
 
 export default defineAction({
   description:
-    "Write or patch a local file (HTML or CSS only) via the localhost design bridge. " +
-    "The user MUST have already granted write consent via grant-localhost-write-consent; " +
-    "this action will reject the request if no valid grant exists. " +
-    "Pass content for a full file write, or {search, replace} for a targeted patch. " +
-    "Requires editor access on the design.",
+    "Write or patch a local file via the localhost design bridge. Accepts " +
+    "common text/code files: HTML, CSS, JS/TS/JSX/TSX, JSON, Markdown, YAML, " +
+    "SVG, Vue/Svelte/Astro, and similar. Secret-looking paths (.env*, *.pem, " +
+    "*.key, id_rsa*, anything under .git/) are always blocked, regardless of " +
+    "extension. The user MUST have already granted write consent via " +
+    "grant-localhost-write-consent; this action will reject the request if no " +
+    "valid grant exists. Pass content for a full file write, or {search, " +
+    "replace} for a targeted patch. Requires editor access on the design.",
   schema: z.object({
     designId: z.string().describe("Design ID."),
     connectionId: z
@@ -118,8 +172,10 @@ export default defineAction({
     relPath: z
       .string()
       .describe(
-        "Path to the file relative to the connection rootPath. " +
-          "Only .html, .htm, and .css files are accepted.",
+        "Path to the file relative to the connection rootPath. Common " +
+          "text/code files are accepted (HTML, CSS, JS/TS/JSX/TSX, JSON, " +
+          "Markdown, YAML, SVG, Vue/Svelte/Astro, and similar); " +
+          "secret-looking paths are always rejected.",
       ),
     content: z
       .string()
@@ -139,8 +195,24 @@ export default defineAction({
         "Search-and-replace patch. Use for targeted edits. " +
           "Mutually exclusive with content.",
       ),
+    expectedVersionHash: z
+      .string()
+      .optional()
+      .describe(
+        "Optional version hash previously returned by read-local-file or a " +
+          "prior write. When provided, the bridge rejects the write with a " +
+          "version-conflict error if the file changed on disk since that " +
+          "hash was read.",
+      ),
   }),
-  run: async ({ designId, connectionId, relPath, content, patch }) => {
+  run: async ({
+    designId,
+    connectionId,
+    relPath,
+    content,
+    patch,
+    expectedVersionHash,
+  }) => {
     // --- Gate 1: access ---
     await assertAccess("design", designId, "editor");
 
@@ -209,13 +281,27 @@ export default defineAction({
       const res = await fetch(`${bridgeUrl}/write-file`, {
         method: "POST",
         headers,
-        body: JSON.stringify({ relPath, content }),
+        body: JSON.stringify({ relPath, content, expectedVersionHash }),
       });
       if (!res.ok) {
+        if (res.status === 409) {
+          throw new Error(
+            `version conflict: "${relPath}" changed on disk since it was last read.`,
+          );
+        }
         const errText = await res.text().catch(() => res.statusText);
         throw bridgeRequestError("write-file", res.status, errText);
       }
-      return { designId, relPath, operation: "write" as const, written: true };
+      const body = (await res.json().catch(() => ({}))) as {
+        versionHash?: string;
+      };
+      return {
+        designId,
+        relPath,
+        operation: "write" as const,
+        written: true,
+        versionHash: body.versionHash,
+      };
     } else {
       // Search-and-replace patch. The bridge's /apply-edit validates the file
       // itself (404s on a missing file), so no pre-read round-trip is needed.
@@ -226,13 +312,28 @@ export default defineAction({
           relPath,
           search: patch!.search,
           replace: patch!.replace,
+          expectedVersionHash,
         }),
       });
       if (!applyRes.ok) {
+        if (applyRes.status === 409) {
+          throw new Error(
+            `version conflict: "${relPath}" changed on disk since it was last read.`,
+          );
+        }
         const errText = await applyRes.text().catch(() => applyRes.statusText);
         throw bridgeRequestError("apply-edit", applyRes.status, errText);
       }
-      return { designId, relPath, operation: "patch" as const, written: true };
+      const body = (await applyRes.json().catch(() => ({}))) as {
+        versionHash?: string;
+      };
+      return {
+        designId,
+        relPath,
+        operation: "patch" as const,
+        written: true,
+        versionHash: body.versionHash,
+      };
     }
   },
 });

package/corpus/templates/design/app/components/design/CanvasContextMenu.tsx

@@ -139,6 +139,13 @@ export interface CanvasContextMenuProps {
   canReorder?: boolean;
   canGroup?: boolean;
   canUngroup?: boolean;
+  // L12: this menu is target-agnostic — it has no built-in notion of "design
+  // title" vs "layer". Rename is enabled by default for a single selection
+  // (see the canRename default below) and fires through the onRename
+  // callback / onAction("rename", ...) regardless of what's selected. Any
+  // "only rename the design title" restriction is a CALL-SITE decision (e.g.
+  // passing canRename={false} and/or hiddenActions={["rename"]} when a layer
+  // is selected instead of the design title) — it does not live here.
   canRename?: boolean;
   canToggleLocked?: boolean;
   canToggleHidden?: boolean;
@@ -173,6 +180,11 @@ export interface CanvasContextMenuProps {
   onSendToBack?: CanvasContextMenuActionHandler;
   onGroup?: CanvasContextMenuActionHandler;
   onUngroup?: CanvasContextMenuActionHandler;
+  // L12: fired when the Rename item is selected (details.selectedCount tells
+  // the caller how many things are selected). The caller decides what
+  // "rename" means for the current target — e.g. calling a LayersPanel
+  // ref's beginRename(layerId) when exactly one layer is selected, vs.
+  // starting design-title rename when nothing is selected.
   onRename?: CanvasContextMenuActionHandler;
   onToggleLocked?: CanvasContextMenuActionHandler;
   onToggleHidden?: CanvasContextMenuActionHandler;