@agent-native/core 0.85.6 → 0.86.0

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

@@ -19,6 +19,16 @@ export default defineAction({
     "for a specific design + localhost connection. The grant scopes writes to the " +
     "connection's rootPath and expires after 8 hours. Requires editor access on the design. " +
     "The LocalhostWriteConsentDialog calls this after the user clicks 'Allow writes'.",
+  // This action mints/returns the real bridgeToken that unlocks the local
+  // bridge's unrestricted /read-file, /write-file, and /apply-edit. It must
+  // only ever be triggered by a human clicking "Allow writes" in
+  // LocalhostWriteConsentDialog — never by the agent itself, or an agent
+  // could self-grant local filesystem write/read access and bypass the
+  // human consent model entirely. `agentTool: false` hides it from every
+  // agent tool surface (in-app assistant, MCP, A2A) while keeping it
+  // callable from the frontend via `callAction` / `useActionMutation` and
+  // the raw `/_agent-native/actions/grant-localhost-write-consent` route.
+  agentTool: false,
   schema: z.object({
     designId: z.string().describe("Design ID."),
     connectionId: z

package/corpus/templates/design/actions/insert-asset.ts

@@ -41,6 +41,27 @@ const schemaInput = z.object({
     .string()
     .optional()
     .describe("Design editor selection owner token from current screen state."),
+  targetNodeId: z
+    .string()
+    .optional()
+    .describe(
+      "data-agent-native-node-id of an existing element to target. Required " +
+        'for mode "replace-src" and "background-fill". Ignored for the ' +
+        'default "figure" mode.',
+    ),
+  mode: z
+    .enum(["figure", "replace-src", "background-fill"])
+    .optional()
+    .default("figure")
+    .describe(
+      'How to place the asset. "figure" (default) appends a new figure/section ' +
+        "at the end of the file, styled with the design's own tokens — use " +
+        'this when there is no existing element to target. "replace-src" sets ' +
+        "the src of the <img>/<video> at targetNodeId (e.g. filling a hero " +
+        'image placeholder). "background-fill" sets a background-image style ' +
+        "on the element at targetNodeId (e.g. filling a hero/section background). " +
+        'Both "replace-src" and "background-fill" require targetNodeId.',
+    ),
 });
 
 function stringFromState(state: unknown, key: string): string | undefined {
@@ -57,6 +78,26 @@ function escapeHtml(value: string): string {
     .replace(/"/g, "&quot;");
 }
 
+/**
+ * Prepare a URL for embedding inside a single-quoted CSS `url('...')` value
+ * that itself lives inside an HTML attribute. A literal `'` in the URL would
+ * otherwise close the CSS string early — and depending on whether the
+ * surrounding HTML attribute is single- or double-quoted, everything after it
+ * becomes live CSS or, worse, live HTML/JS in the script-enabled preview
+ * iframe. Percent-encoding the quote/backslash characters that are meaningful
+ * to the CSS string-literal grammar keeps the URL functionally identical
+ * (browsers resolve %27/%22/%5C the same as the raw characters) while making
+ * it impossible to break out of the `url('...')` string. HTML-escape on top
+ * so the value is also safe as an HTML attribute (covers the "..." case).
+ */
+function cssUrlValue(value: string): string {
+  const cssSafe = value
+    .replace(/\\/g, "%5C")
+    .replace(/'/g, "%27")
+    .replace(/"/g, "%22");
+  return escapeHtml(cssSafe);
+}
+
 function createInsertedNodeId(prefix: string): string {
   const random =
     typeof crypto !== "undefined" && typeof crypto.randomUUID === "function"
@@ -88,13 +129,13 @@ function appendAssetMarkup(
     : "";
   const media =
     args.mediaType === "video"
-      ? `<video src="${escapedUrl}" controls class="w-full rounded-xl object-cover"></video>`
-      : `<img src="${escapedUrl}" alt="${escapeHtml(args.altText?.trim() || label)}" class="w-full rounded-xl object-cover" />`;
+      ? `<video src="${escapedUrl}" controls class="w-full rounded-[var(--radius,0.75rem)] object-cover"></video>`
+      : `<img src="${escapedUrl}" alt="${escapeHtml(args.altText?.trim() || label)}" class="w-full rounded-[var(--radius,0.75rem)] object-cover" />`;
   const snippet = `
     <section class="mx-auto my-8 max-w-5xl px-4" data-agent-native-asset data-agent-native-node-id="${escapeHtml(nodeId)}" data-agent-native-layer-name="${escapedLabel}"${assetIdAttr}>
-      <figure class="overflow-hidden rounded-2xl border border-slate-200 bg-white shadow-sm">
+      <figure class="overflow-hidden rounded-[var(--radius,1rem)] border border-[var(--color-border,rgba(0,0,0,0.1))] bg-[var(--color-surface,#fff)] shadow-sm">
         ${media}
-        <figcaption class="px-4 py-3 text-sm text-slate-600">${escapedLabel}</figcaption>
+        <figcaption class="px-4 py-3 text-sm text-[var(--color-text-muted,#64748b)]">${escapedLabel}</figcaption>
       </figure>
     </section>`;
 
@@ -105,6 +146,119 @@ function appendAssetMarkup(
   );
 }
 
+/** Find the raw tag string for the element carrying the given node id. */
+function findTagByNodeId(html: string, nodeId: string): string | null {
+  const escapedId = nodeId.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  const pattern = new RegExp(
+    `<[a-zA-Z][a-zA-Z0-9:-]*\\b[^>]*data-agent-native-node-id\\s*=\\s*(?:"${escapedId}"|'${escapedId}')[^>]*>`,
+  );
+  const match = html.match(pattern);
+  return match ? match[0] : null;
+}
+
+/** Replace the src attribute of the <img>/<video> tag at targetNodeId. */
+function replaceSrcAtNode(
+  html: string,
+  args: z.infer<typeof schemaInput>,
+): string {
+  const nodeId = args.targetNodeId!;
+  const tag = findTagByNodeId(html, nodeId);
+  if (!tag) {
+    throw new Error(
+      `No element found with data-agent-native-node-id="${nodeId}".`,
+    );
+  }
+  const escapedUrl = escapeHtml(args.assetUrl);
+  let nextTag: string;
+  if (/\bsrc\s*=\s*(?:"[^"]*"|'[^']*')/i.test(tag)) {
+    nextTag = tag.replace(
+      /\bsrc\s*=\s*(?:"[^"]*"|'[^']*')/i,
+      `src="${escapedUrl}"`,
+    );
+  } else {
+    nextTag = tag.replace(/\/?>\s*$/, ` src="${escapedUrl}">`);
+  }
+  if (args.altText?.trim()) {
+    const escapedAlt = escapeHtml(args.altText.trim());
+    nextTag = /\balt\s*=\s*(?:"[^"]*"|'[^']*')/i.test(nextTag)
+      ? nextTag.replace(
+          /\balt\s*=\s*(?:"[^"]*"|'[^']*')/i,
+          `alt="${escapedAlt}"`,
+        )
+      : nextTag.replace(/\/?>\s*$/, ` alt="${escapedAlt}">`);
+  }
+  if (args.assetId?.trim()) {
+    const escapedAssetId = escapeHtml(args.assetId.trim());
+    nextTag = /\bdata-asset-id\s*=/.test(nextTag)
+      ? nextTag.replace(
+          /\bdata-asset-id\s*=\s*(?:"[^"]*"|'[^']*')/i,
+          `data-asset-id="${escapedAssetId}"`,
+        )
+      : nextTag.replace(/\/?>\s*$/, ` data-asset-id="${escapedAssetId}">`);
+  }
+  return html.replace(tag, nextTag);
+}
+
+/** Set a background-image inline style on the element at targetNodeId. */
+function backgroundFillAtNode(
+  html: string,
+  args: z.infer<typeof schemaInput>,
+): string {
+  const nodeId = args.targetNodeId!;
+  const tag = findTagByNodeId(html, nodeId);
+  if (!tag) {
+    throw new Error(
+      `No element found with data-agent-native-node-id="${nodeId}".`,
+    );
+  }
+  const cssUrl = cssUrlValue(args.assetUrl);
+  const bgDeclaration = `background-image: url('${cssUrl}'); background-size: cover; background-position: center;`;
+  let nextTag: string;
+  if (/\bstyle\s*=\s*"/.test(tag)) {
+    nextTag = tag.replace(
+      /\bstyle\s*=\s*"([^"]*)"/i,
+      (_match, existing: string) => {
+        const trimmed = existing.trim();
+        const withoutBgImage = trimmed.replace(
+          /background-image\s*:[^;]*;?\s*/gi,
+          "",
+        );
+        const joined = withoutBgImage
+          ? `${withoutBgImage.replace(/;\s*$/, "")}; ${bgDeclaration}`
+          : bgDeclaration;
+        return `style="${joined}"`;
+      },
+    );
+  } else if (/\bstyle\s*=\s*'/.test(tag)) {
+    nextTag = tag.replace(
+      /\bstyle\s*=\s*'([^']*)'/i,
+      (_match, existing: string) => {
+        const trimmed = existing.trim();
+        const withoutBgImage = trimmed.replace(
+          /background-image\s*:[^;]*;?\s*/gi,
+          "",
+        );
+        const joined = withoutBgImage
+          ? `${withoutBgImage.replace(/;\s*$/, "")}; ${bgDeclaration}`
+          : bgDeclaration;
+        return `style='${joined}'`;
+      },
+    );
+  } else {
+    nextTag = tag.replace(/\/?>\s*$/, ` style="${bgDeclaration}">`);
+  }
+  if (args.assetId?.trim()) {
+    const escapedAssetId = escapeHtml(args.assetId.trim());
+    nextTag = /\bdata-asset-id\s*=/.test(nextTag)
+      ? nextTag.replace(
+          /\bdata-asset-id\s*=\s*(?:"[^"]*"|'[^']*')/i,
+          `data-asset-id="${escapedAssetId}"`,
+        )
+      : nextTag.replace(/\/?>\s*$/, ` data-asset-id="${escapedAssetId}">`);
+  }
+  return html.replace(tag, nextTag);
+}
+
 async function resolveTarget(args: z.infer<typeof schemaInput>) {
   const [navigation, selection] = await Promise.all([
     readAppStateForCurrentTab("navigation").catch(() => null),
@@ -149,7 +303,18 @@ function isHtmlFile(file: {
 
 export default defineAction({
   description:
-    "Insert a chosen Assets image or video URL into a Design file. Use this after the Assets picker returns chooseAsset/chooseImage context; pass designId/fileId directly when known, or pass ownerId from view-screen.designSelection when targeting the current editor selection.",
+    "Insert a chosen Assets image or video URL into a Design file. Use this " +
+    "after the Assets picker returns chooseAsset/chooseImage context; pass " +
+    "designId/fileId directly when known, or pass ownerId from " +
+    "view-screen.designSelection when targeting the current editor selection. " +
+    'Default `mode: "figure"` appends a new tokened figure/section at the end ' +
+    "of the file — use this when there is no existing element to fill. Use " +
+    '`mode: "replace-src"` with `targetNodeId` to set the src of an existing ' +
+    "<img>/<video> (e.g. filling a hero image placeholder), or " +
+    '`mode: "background-fill"` with `targetNodeId` to set a background-image ' +
+    "style on an existing element (e.g. filling a hero/section background). " +
+    "Both of those require targetNodeId (a data-agent-native-node-id) from " +
+    "get-code-layer-projection or the current selection.",
   schema: schemaInput,
   publicAgent: { expose: true, readOnly: false, requiresAuth: true },
   run: async (args) => {
@@ -200,8 +365,25 @@ export default defineAction({
       // Collab read is best-effort; fall back to stored content.
     }
 
-    const insertedNodeId = createInsertedNodeId("asset");
-    const content = appendAssetMarkup(base, args, insertedNodeId);
+    const mode = args.mode ?? "figure";
+    let content: string;
+    let insertedNodeId: string;
+    if (mode === "replace-src") {
+      if (!args.targetNodeId) {
+        throw new Error('targetNodeId is required for mode "replace-src".');
+      }
+      insertedNodeId = args.targetNodeId;
+      content = replaceSrcAtNode(base, args);
+    } else if (mode === "background-fill") {
+      if (!args.targetNodeId) {
+        throw new Error('targetNodeId is required for mode "background-fill".');
+      }
+      insertedNodeId = args.targetNodeId;
+      content = backgroundFillAtNode(base, args);
+    } else {
+      insertedNodeId = createInsertedNodeId("asset");
+      content = appendAssetMarkup(base, args, insertedNodeId);
+    }
     const now = new Date().toISOString();
     await db
       .update(schema.designFiles)
@@ -223,6 +405,7 @@ export default defineAction({
       fileId: file.id,
       filename: file.filename,
       inserted: true,
+      mode,
       insertedNodeId,
       insertedSelector: `[data-agent-native-node-id="${insertedNodeId}"]`,
       assetId: args.assetId ?? null,

package/corpus/templates/design/actions/list-fusion-edits.ts

@@ -0,0 +1,96 @@
+/**
+ * list-fusion-edits — read-only list of queued fusion edit instructions for a
+ * design.
+ *
+ * Viewer access is sufficient since this is a read. Returns edits ordered
+ * oldest-first (the order apply-fusion-edits will present them to the app
+ * agent) plus a pendingCount convenience field.
+ */
+
+import { defineAction } from "@agent-native/core";
+import { accessFilter } from "@agent-native/core/sharing";
+import { and, asc, 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 { FULL_APP_BUILDING_ENABLED } from "../shared/full-app.js";
+
+function parseTarget(raw: string | null): Record<string, unknown> | null {
+  if (!raw) return null;
+  try {
+    const parsed = JSON.parse(raw) as unknown;
+    return parsed && typeof parsed === "object" && !Array.isArray(parsed)
+      ? (parsed as Record<string, unknown>)
+      : null;
+  } catch {
+    return null;
+  }
+}
+
+export default defineAction({
+  description:
+    "List queued fusion (full-app) visual edit instructions for a design, " +
+    "oldest first. Optionally filter by status (pending|sent|error). Use to " +
+    "review what's queued before calling apply-fusion-edits, or to check the " +
+    "outcome of a previous batch.",
+  schema: z.object({
+    designId: z.string().describe("Design project ID backed by a fusion app."),
+    status: z
+      .enum(["pending", "sent", "error"])
+      .optional()
+      .describe("Filter to edits with this status. Omit to return all."),
+  }),
+  readOnly: true,
+  http: { method: "GET" },
+  run: async ({ designId, status }) => {
+    if (!FULL_APP_BUILDING_ENABLED) {
+      throw new Error("Full app building is not enabled");
+    }
+
+    const db = getDb();
+
+    const [design] = await db
+      .select({ id: schema.designs.id })
+      .from(schema.designs)
+      .where(
+        and(
+          accessFilter(schema.designs, schema.designShares),
+          eq(schema.designs.id, designId),
+        ),
+      )
+      .limit(1);
+    if (!design) {
+      const err = new Error("Design not found") as Error & {
+        statusCode: number;
+      };
+      err.statusCode = 404;
+      throw err;
+    }
+
+    const conditions = [eq(schema.designFusionEdits.designId, designId)];
+    if (status) conditions.push(eq(schema.designFusionEdits.status, status));
+
+    const rows = await db
+      .select()
+      .from(schema.designFusionEdits)
+      .where(and(...conditions))
+      .orderBy(asc(schema.designFusionEdits.createdAt));
+
+    const edits = rows.map((row) => ({
+      id: row.id,
+      instruction: row.instruction,
+      target: parseTarget(row.target),
+      status: row.status,
+      screenFileId: row.screenFileId,
+      batchId: row.batchId,
+      error: row.error,
+      sentAt: row.sentAt,
+      createdAt: row.createdAt,
+    }));
+
+    const pendingCount = rows.filter((row) => row.status === "pending").length;
+
+    return { edits, pendingCount };
+  },
+});

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

@@ -0,0 +1,133 @@
+/**
+ * list-local-files — list files under a connected local app's root via the
+ * design bridge.
+ *
+ * Security gates (in order), mirroring write-local-file.ts minus the write
+ * grant (reads do not require user write consent, only editor access + a
+ * valid bridge connection):
+ *  1. assertAccess: the caller must have editor access to the design.
+ *  2. Bridge URL resolution: only the current user's own connection row.
+ *  3. Loopback check: bridgeUrl must resolve to localhost/127.0.0.1.
+ *  4. Bridge token: the connection's stored bridge token is sent as
+ *     X-Bridge-Token so the bridge can reject unauthorized callers.
+ */
+
+import { defineAction } from "@agent-native/core";
+import { getRequestUserEmail } from "@agent-native/core/server/request-context";
+import { assertAccess } from "@agent-native/core/sharing";
+import { and, eq } from "drizzle-orm";
+import { z } from "zod";
+
+import { getDb, schema } from "../server/db/index.js";
+
+function isLoopbackHostname(hostname: string): boolean {
+  const normalized = hostname.toLowerCase();
+  if (
+    normalized === "localhost" ||
+    normalized === "::1" ||
+    normalized === "[::1]"
+  ) {
+    return true;
+  }
+  const parts = normalized.split(".");
+  return (
+    parts.length === 4 &&
+    parts[0] === "127" &&
+    parts.every((part) => /^\d+$/.test(part) && Number(part) <= 255)
+  );
+}
+
+function normalizeBridgeUrl(value: string): string {
+  const parsed = new URL(value.trim());
+  if (parsed.protocol !== "http:" && parsed.protocol !== "https:") {
+    throw new Error("bridgeUrl must be an http(s) URL");
+  }
+  if (parsed.username || parsed.password) {
+    throw new Error("bridgeUrl must not include credentials");
+  }
+  if (parsed.pathname !== "/" && parsed.pathname !== "") {
+    throw new Error("bridgeUrl must not include a path");
+  }
+  if (!isLoopbackHostname(parsed.hostname)) {
+    throw new Error("bridgeUrl must use localhost or a loopback IP address");
+  }
+  parsed.search = "";
+  parsed.hash = "";
+  parsed.pathname = "";
+  return parsed.toString().replace(/\/$/, "");
+}
+
+export default defineAction({
+  description:
+    "List files under a connected local app's root via the localhost design " +
+    "bridge. Read-only — does not require a write-consent grant, but does " +
+    "require editor access on the design and a running bridge connection. " +
+    "Returns root-relative paths and sizes, already filtered by the bridge's " +
+    ".gitignore-aware ignore rules, binary/size limits, and secret-path " +
+    "blocklist (.env*, *.pem, *.key, id_rsa*, .git/).",
+  schema: z.object({
+    designId: z.string().describe("Design ID."),
+    connectionId: z.string().describe("Localhost connection ID."),
+  }),
+  readOnly: true,
+  http: { method: "GET" },
+  run: async ({ designId, connectionId }) => {
+    await assertAccess("design", designId, "editor");
+
+    const ownerEmail = getRequestUserEmail();
+    if (!ownerEmail) throw new Error("no authenticated user");
+
+    const db = getDb();
+    const [connection] = await db
+      .select({
+        bridgeUrl: schema.designLocalhostConnections.bridgeUrl,
+        bridgeToken: schema.designLocalhostConnections.bridgeToken,
+      })
+      .from(schema.designLocalhostConnections)
+      .where(
+        and(
+          eq(schema.designLocalhostConnections.id, connectionId),
+          eq(schema.designLocalhostConnections.ownerEmail, ownerEmail),
+        ),
+      )
+      .limit(1);
+
+    if (!connection?.bridgeUrl) {
+      throw new Error(
+        `No bridge URL found for connection "${connectionId}". ` +
+          "Ensure the design bridge is running (npx @agent-native/core@latest design connect).",
+      );
+    }
+    if (!connection.bridgeToken) {
+      throw new Error(
+        `No bridge token found for connection "${connectionId}". ` +
+          "Reconnect via npx @agent-native/core@latest design connect.",
+      );
+    }
+
+    const bridgeUrl = normalizeBridgeUrl(connection.bridgeUrl);
+    const res = await fetch(`${bridgeUrl}/list-files`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "X-Bridge-Token": connection.bridgeToken,
+      },
+      body: JSON.stringify({}),
+    });
+    if (!res.ok) {
+      const errText = await res.text().catch(() => res.statusText);
+      throw new Error(`Bridge list-files failed (${res.status}): ${errText}`);
+    }
+    const body = (await res.json()) as {
+      files?: Array<{ path: string; size: number }>;
+      truncated?: boolean;
+    };
+
+    return {
+      designId,
+      connectionId,
+      files: body.files ?? [],
+      truncated: body.truncated ?? false,
+    };
+  },
+});

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

@@ -3,6 +3,7 @@ import crypto from "node:crypto";
 import { defineAction, embedApp } from "@agent-native/core";
 import { writeAppState } from "@agent-native/core/application-state";
 import { buildDeepLink } from "@agent-native/core/server";
+import { getRequestUserEmail } from "@agent-native/core/server/request-context";
 import { eq } from "drizzle-orm";
 import { z } from "zod";
 
@@ -88,10 +89,23 @@ function isLoopbackUrl(value: string): boolean {
   );
 }
 
-function stableConnectionId(devServerUrl: string, rootPath?: string) {
+/**
+ * Derive a stable per-user connection id for a devServerUrl + rootPath pair.
+ *
+ * The owner email is embedded in the hash so two users with an identical
+ * devServerUrl + rootPath (common with devcontainers/codespaces images) derive
+ * DIFFERENT ids and never collide on the shared primary key. Connections
+ * created before user scoping keep their old ids; those users simply
+ * reconnect fresh under the new per-user id.
+ */
+function stableConnectionId(
+  devServerUrl: string,
+  rootPath: string | undefined,
+  ownerEmail: string,
+) {
   const hash = crypto
     .createHash("sha256")
-    .update(`${devServerUrl}\n${rootPath ?? ""}`)
+    .update(`${ownerEmail}\n${devServerUrl}\n${rootPath ?? ""}`)
     .digest("base64url")
     .slice(0, 16);
   return `localhost_${hash}`;
@@ -147,7 +161,7 @@ export default defineAction({
       .string()
       .optional()
       .describe(
-        "Existing localhost connection. Omit to reuse a stable connection for devServerUrl + rootPath.",
+        "Existing localhost connection. Omit to reuse a stable per-user connection for devServerUrl + rootPath.",
       ),
     title: z
       .string()
@@ -240,8 +254,16 @@ export default defineAction({
             }) ?? [],
           generatedAt: new Date().toISOString(),
         };
-    const connectionId =
-      args.connectionId ?? stableConnectionId(devServerUrl, args.rootPath);
+    let connectionId = args.connectionId;
+    if (!connectionId) {
+      const ownerEmail = getRequestUserEmail();
+      if (!ownerEmail) throw new Error("no authenticated user");
+      connectionId = stableConnectionId(
+        devServerUrl,
+        args.rootPath,
+        ownerEmail,
+      );
+    }
 
     const connection = await connectLocalhostAction.run({
       id: connectionId,

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

@@ -250,7 +250,7 @@ function colorForVariant(
 ) {
   const provided = variant.accentColor?.trim();
   if (provided) return provided;
-  return ["#8b5cf6", "#06b6d4", "#10b981", "#f43f5e", "#f59e0b"][index % 5]!;
+  return ["#f59e0b", "#06b6d4", "#10b981", "#f43f5e", "#d97706"][index % 5]!;
 }
 
 function fallbackVariantContent(
@@ -307,7 +307,7 @@ function fallbackVariantContent(
 <style>
 :root { color-scheme: dark; --accent: ${accent}; --bg: #080a0f; --panel: rgba(18, 22, 33, 0.82); --line: rgba(255,255,255,.11); --muted: #94a3b8; }
 * { box-sizing: border-box; }
-body { margin: 0; width: ${screenWidth}px; min-height: ${screenHeight}px; overflow: hidden; font-family: Inter, ui-sans-serif, system-ui, -apple-system, BlinkMacSystemFont, "Segoe UI", sans-serif; color: #f8fafc; background:
+body { margin: 0; width: ${screenWidth}px; min-height: ${screenHeight}px; overflow: hidden; font-family: ui-sans-serif, system-ui, -apple-system, BlinkMacSystemFont, "Segoe UI", sans-serif; color: #f8fafc; background:
   radial-gradient(circle at 18% 8%, color-mix(in srgb, var(--accent) 42%, transparent), transparent 30%),
   linear-gradient(140deg, #05070b 0%, #111827 48%, #05070b 100%); }
 .shell { width: ${screenWidth}px; min-height: ${screenHeight}px; padding: ${compact ? "18" : "34"}px; display: grid; grid-template-columns: ${compact ? "1fr" : tablet ? "220px 1fr" : "258px 1fr 304px"}; gap: ${compact ? "14" : "22"}px; }

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

@@ -0,0 +1,62 @@
+/**
+ * push-fusion-app — push a fusion branch's code to its git remote.
+ *
+ * Use when the user wants the in-progress app code synced to git (e.g. before
+ * handing off to another tool, or as a checkpoint) without necessarily
+ * deploying it.
+ */
+
+import { defineAction } from "@agent-native/core";
+import { pushFusionBranch } from "@agent-native/core/server";
+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";
+
+function asString(value: unknown): string | undefined {
+  return typeof value === "string" && value.trim() ? value.trim() : undefined;
+}
+
+export default defineAction({
+  description:
+    "Push a fusion (full-app) design's branch code to its git remote. Use " +
+    "when the user wants the current app code synced to git as a checkpoint " +
+    "or before handing off elsewhere. Does not deploy or affect the live " +
+    "container preview — use deploy-fusion-app for a hosted deploy.",
+  schema: z.object({
+    designId: z.string().describe("Design project ID backed by a fusion app."),
+  }),
+  run: async ({ designId }) => {
+    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 record = await pushFusionBranch({
+      projectId: fusionApp.projectId,
+      branchName: fusionApp.branchName,
+    });
+
+    const detail =
+      asString(record.message) ??
+      asString(record.commit) ??
+      asString(record.sha) ??
+      asString(record.status) ??
+      JSON.stringify(record).slice(0, 500);
+
+    return { ok: true as const, detail };
+  },
+});