@hyperframes/studio-server 0.7.56 → 0.7.58

package/dist/index.js

@@ -896,6 +896,21 @@ function resolveProjectFile(c, adapter, opts) {
 function resolveFileMutationContext(c, adapter, operation) {
   return resolveProjectPath(c, adapter, (id) => `/projects/${id}/file-mutations/${operation}/`);
 }
+function isElementPatchRequest(value) {
+  if (typeof value !== "object" || value === null) return false;
+  if (!("target" in value) || typeof value.target !== "object" || value.target === null) {
+    return false;
+  }
+  return "operations" in value && Array.isArray(value.operations) && value.operations.length > 0;
+}
+function isElementPatchBatchRequest(value) {
+  return typeof value === "object" && value !== null && "sourceFile" in value && typeof value.sourceFile === "string" && value.sourceFile.length > 0 && "patches" in value && Array.isArray(value.patches) && value.patches.length > 0 && value.patches.every(isElementPatchRequest);
+}
+function findUnsafeElementPatchBatchValues(batches) {
+  return batches.flatMap(
+    (batch) => batch.patches.flatMap((patch) => findUnsafeDomPatchValues(patch))
+  );
+}
 function foldElementPatches(originalContent, patches) {
   let content = originalContent;
   const matched = [];
@@ -906,6 +921,90 @@ function foldElementPatches(originalContent, patches) {
   }
   return { content, matched };
 }
+function commitElementPatchBatches(projectDir, batches, writeFile = writeFileSync4) {
+  const resolvedPaths = /* @__PURE__ */ new Set();
+  const prepared = [];
+  for (const batch of batches) {
+    const absPath = resolveWithinProject(projectDir, batch.sourceFile);
+    if (!absPath) return { error: "forbidden", sourceFile: batch.sourceFile };
+    if (resolvedPaths.has(absPath)) return { error: "duplicate", sourceFile: batch.sourceFile };
+    resolvedPaths.add(absPath);
+    let before;
+    try {
+      before = readFileSync3(absPath, "utf-8");
+    } catch {
+      return { error: "not-found", sourceFile: batch.sourceFile };
+    }
+    const folded = foldElementPatches(before, batch.patches);
+    prepared.push({
+      sourceFile: batch.sourceFile,
+      absPath,
+      before,
+      matched: folded.matched,
+      after: folded.content
+    });
+  }
+  const durable = prepared.every((file) => file.matched.every(Boolean));
+  if (!durable) {
+    return {
+      durable: false,
+      files: prepared.map((file) => ({
+        sourceFile: file.sourceFile,
+        changed: false,
+        matched: file.matched,
+        before: file.before,
+        after: file.before
+      }))
+    };
+  }
+  const files = [];
+  const attemptedWrites = [];
+  try {
+    for (const file of prepared) {
+      if (file.after === file.before) {
+        files.push({
+          sourceFile: file.sourceFile,
+          changed: false,
+          matched: file.matched,
+          before: file.before,
+          after: file.before
+        });
+        continue;
+      }
+      const backup = snapshotBeforeWrite(projectDir, file.absPath);
+      if (backup.error) {
+        throw new Error(`Failed to create backup for ${file.sourceFile}: ${backup.error}`);
+      }
+      attemptedWrites.push(file);
+      writeFile(file.absPath, file.after, "utf-8");
+      files.push({
+        sourceFile: file.sourceFile,
+        changed: true,
+        matched: file.matched,
+        before: file.before,
+        after: file.after,
+        backupPath: backupPathForResponse(projectDir, backup.backupPath)
+      });
+    }
+  } catch (error) {
+    const rollbackErrors = [];
+    for (const file of attemptedWrites.reverse()) {
+      try {
+        writeFile(file.absPath, file.before, "utf-8");
+      } catch (rollbackError) {
+        rollbackErrors.push(rollbackError);
+      }
+    }
+    if (rollbackErrors.length > 0) {
+      throw new AggregateError(
+        [error, ...rollbackErrors],
+        "Element patch batch failed and rollback did not complete"
+      );
+    }
+    throw error;
+  }
+  return { durable: true, files };
+}
 function writeIfChanged(c, projectDir, filePath, absPath, original, next) {
   if (next === original) {
     return c.json({ ok: true, changed: false, content: original, path: filePath });
@@ -931,6 +1030,11 @@ function rejectUnsafeMutationValues(c, unsafeFields) {
     400
   );
 }
+function elementPatchBatchCommitErrorResponse(c, error, sourceFile) {
+  if (error === "not-found") return c.json({ error, sourceFile }, 404);
+  if (error === "forbidden") return c.json({ error, sourceFile }, 403);
+  return c.json({ error: "duplicate source file", sourceFile }, 400);
+}
 async function parseMutationBody(c) {
   const body = await c.req.json().catch(() => null);
   if (!body?.target) {
@@ -1233,7 +1337,8 @@ function validateGsapMutationRequest(c, body) {
   return null;
 }
 async function prepareGsapMutationScript(c, res, firstMutation) {
-  let html = readFileSync3(res.absPath, "utf-8");
+  const beforeHtml = readFileSync3(res.absPath, "utf-8");
+  let html = beforeHtml;
   let block = extractGsapScriptBlock(html);
   if (!block && (firstMutation.type === "add" || firstMutation.type === "add-with-keyframes")) {
     const compId = html.match(/data-composition-id="([^"]+)"/)?.[1] ?? "main";
@@ -1265,14 +1370,14 @@ ${bootstrap}`;
     });
   }
   if (!block) return c.json({ error: "no GSAP script found in file" }, 400);
-  return { html, block };
+  return { html, beforeHtml, block };
 }
 async function applyGsapMutations(c, res, mutations) {
   const firstMutation = mutations[0];
   if (!firstMutation) return c.json({ error: "mutations array required" }, 400);
   const prepared = await prepareGsapMutationScript(c, res, firstMutation);
   if (prepared instanceof Response) return prepared;
-  const { html, block } = prepared;
+  const { html, beforeHtml, block } = prepared;
   const initialScript = block.scriptText;
   const skippedSelectors = /* @__PURE__ */ new Set();
   const respond = (data, status) => status ? c.json(data, status) : c.json(data);
@@ -1292,6 +1397,9 @@ async function applyGsapMutations(c, res, mutations) {
   const changed = block.scriptText !== initialScript;
   const newHtml = changed ? block.replaceScript(block.scriptText) : html;
   let backupPath = null;
+  if (readFileSync3(res.absPath, "utf-8") !== beforeHtml) {
+    return c.json({ error: "file changed during GSAP mutation", conflict: true }, 409);
+  }
   if (changed) {
     const backup = snapshotBeforeWrite(res.project.dir, res.absPath);
     if (backup.error) console.warn(`Failed to create backup for ${res.filePath}: ${backup.error}`);
@@ -1303,7 +1411,7 @@ async function applyGsapMutations(c, res, mutations) {
     changed,
     mutated: changed,
     parsed: parseGsapScriptAcorn(block.scriptText),
-    before: html,
+    before: beforeHtml,
     after: newHtml,
     scriptText: block.scriptText,
     path: res.filePath,
@@ -2112,45 +2220,46 @@ function registerFileRoutes(api, adapter) {
       backupPath: backupPathForResponse(ctx.project.dir, backup.backupPath)
     });
   });
+  api.post("/projects/:id/file-mutations/patch-element-batches", async (c) => {
+    const project = await adapter.resolveProject(c.req.param("id"));
+    if (!project) return c.json({ error: "not found" }, 404);
+    const body = await c.req.json().catch(() => null);
+    if (typeof body !== "object" || body === null || !("batches" in body) || !Array.isArray(body.batches) || body.batches.length === 0 || !body.batches.every(isElementPatchBatchRequest)) {
+      return c.json({ error: "batches with sourceFile and patches required" }, 400);
+    }
+    const unsafeFields = findUnsafeElementPatchBatchValues(body.batches);
+    if (unsafeFields.length > 0) return rejectUnsafeMutationValues(c, unsafeFields);
+    const result = commitElementPatchBatches(project.dir, body.batches);
+    if ("error" in result) {
+      return elementPatchBatchCommitErrorResponse(c, result.error, result.sourceFile);
+    }
+    return c.json(result);
+  });
   api.post("/projects/:id/file-mutations/patch-elements-batch/*", async (c) => {
     const ctx = await resolveFileMutationContext(c, adapter, "patch-elements-batch");
     if ("error" in ctx) return ctx.error;
     const body = await c.req.json().catch(() => null);
-    if (!body || !Array.isArray(body.patches) || body.patches.length === 0 || body.patches.some(
-      (patch) => !patch?.target || !Array.isArray(patch.operations) || patch.operations.length === 0
-    )) {
+    if (!body || !Array.isArray(body.patches) || body.patches.length === 0 || !body.patches.every(isElementPatchRequest)) {
       return c.json({ error: "patches with target and operations required" }, 400);
     }
-    const unsafeFields = body.patches.flatMap((patch) => findUnsafeDomPatchValues(patch));
+    const batch = { sourceFile: ctx.filePath, patches: body.patches };
+    const unsafeFields = findUnsafeElementPatchBatchValues([batch]);
     if (unsafeFields.length > 0) {
       return rejectUnsafeMutationValues(c, unsafeFields);
     }
-    let originalContent;
-    try {
-      originalContent = readFileSync3(ctx.absPath, "utf-8");
-    } catch {
-      return c.json({ error: "not found" }, 404);
-    }
-    const result = foldElementPatches(originalContent, body.patches);
-    if (result.content === originalContent) {
-      return c.json({
-        ok: true,
-        changed: false,
-        matched: result.matched,
-        content: originalContent,
-        path: ctx.filePath
-      });
+    const result = commitElementPatchBatches(ctx.project.dir, [batch]);
+    if ("error" in result) {
+      return elementPatchBatchCommitErrorResponse(c, result.error, result.sourceFile);
     }
-    const backup = snapshotBeforeWrite(ctx.project.dir, ctx.absPath);
-    if (backup.error) console.warn(`Failed to create backup for ${ctx.filePath}: ${backup.error}`);
-    writeFileSync4(ctx.absPath, result.content, "utf-8");
+    const file = result.files[0];
+    if (!file) return c.json({ error: "empty element patch result" }, 500);
     return c.json({
       ok: true,
-      changed: true,
-      matched: result.matched,
-      content: result.content,
-      path: ctx.filePath,
-      backupPath: backupPathForResponse(ctx.project.dir, backup.backupPath)
+      changed: file.changed,
+      matched: file.matched,
+      content: file.after,
+      path: file.sourceFile,
+      backupPath: file.backupPath
     });
   });
   api.post("/projects/:id/file-mutations/wrap-elements/*", async (c) => {
@@ -2328,6 +2437,11 @@ function registerFileRoutes(api, adapter) {
     const parsed = parseGsapScriptAcorn(block.scriptText);
     return c.json(parsed);
   });
+  api.get("/projects/:id/gsap-mutation-capabilities", async (c) => {
+    const project = await adapter.resolveProject(c.req.param("id"));
+    if (!project) return c.json({ error: "not found" }, 404);
+    return c.json({ atomicOwnershipPairs: true });
+  });
   api.post("/projects/:id/gsap-mutations/*", async (c) => {
     const res = await resolveProjectPath(c, adapter, (id) => `/projects/${id}/gsap-mutations/`, {
       mustExist: true
@@ -2357,6 +2471,25 @@ function registerFileRoutes(api, adapter) {
     }
     return applyGsapMutations(c, res, body.mutations);
   });
+  api.post("/projects/:id/gsap-mutation-rollback/*", async (c) => {
+    const res = await resolveProjectPath(
+      c,
+      adapter,
+      (id) => `/projects/${id}/gsap-mutation-rollback/`,
+      { mustExist: true }
+    );
+    if ("error" in res) return res.error;
+    const body = await c.req.json().catch(() => null);
+    if (!body || typeof body.expected !== "string" || typeof body.restore !== "string") {
+      return c.json({ error: "expected and restore contents required" }, 400);
+    }
+    const current = readFileSync3(res.absPath, "utf-8");
+    if (current !== body.expected) {
+      return c.json({ ok: true, restored: false, conflict: true });
+    }
+    writeFileSync4(res.absPath, body.restore, "utf-8");
+    return c.json({ ok: true, restored: true, conflict: false });
+  });
 }
 
 // src/routes/preview.ts