@agent-native/core 0.164.11 → 0.164.15

package/corpus/templates/factory/actions/restore-factory-graph-version.ts

@@ -0,0 +1,163 @@
+import { defineAction } from "@agent-native/core/action";
+import { buildDeepLink } from "@agent-native/core/server";
+import { and, eq } from "drizzle-orm";
+import { z } from "zod";
+
+import { getDb } from "../server/db/index.js";
+import {
+  factoryDefinitions,
+  factoryGraphVersions,
+} from "../server/db/schema.js";
+import { normalizeFactoryGraph } from "../server/factory-graph/contracts.js";
+import {
+  DEFAULT_FACTORY_ID,
+  parseFactoryGraph,
+} from "../server/factory-graph/store.js";
+import {
+  requireWorkspaceMember,
+  workspaceMemberIdentityFromContext,
+} from "../server/lib/require-workspace-member.js";
+import { stableId } from "../server/triage/ids.js";
+
+export default defineAction({
+  description:
+    "Restore a Factory visual graph version. Restoring never deletes history: it validates the selected snapshot, appends it as a new version, and makes that new version current while preserving the Factory prompt.",
+  schema: z.object({
+    factoryId: z
+      .string()
+      .trim()
+      .min(1)
+      .max(120)
+      .regex(/^[a-z0-9][a-z0-9-]*$/)
+      .default(DEFAULT_FACTORY_ID),
+    versionId: z.string().trim().min(1).max(240),
+  }),
+  link: ({ result }) => ({
+    url: buildDeepLink({
+      app: "factory",
+      view: "factory",
+      params: { factoryId: result.factoryId, tab: "history" },
+    }),
+    label: `Open ${result.name} history in Factory`,
+  }),
+  run: async ({ factoryId, versionId }, context) => {
+    const { userEmail, orgId } = await requireWorkspaceMember(
+      workspaceMemberIdentityFromContext(context),
+    );
+    const db = getDb();
+
+    return db.transaction(async (tx) => {
+      const definition = (
+        await tx
+          .select()
+          .from(factoryDefinitions)
+          .where(
+            and(
+              eq(factoryDefinitions.id, factoryId),
+              eq(factoryDefinitions.orgId, orgId),
+            ),
+          )
+          .limit(1)
+      )[0];
+      if (!definition) {
+        throw new Error("Factory has no saved definition to restore.");
+      }
+
+      const version = (
+        await tx
+          .select()
+          .from(factoryGraphVersions)
+          .where(
+            and(
+              eq(factoryGraphVersions.id, versionId),
+              eq(factoryGraphVersions.factoryId, factoryId),
+              eq(factoryGraphVersions.orgId, orgId),
+            ),
+          )
+          .limit(1)
+      )[0];
+      if (!version) {
+        throw new Error("Factory graph version not found.");
+      }
+
+      const selectedGraph = parseFactoryGraph(version.graphJson);
+
+      if (version.version === definition.graphVersion) {
+        return {
+          ok: true,
+          alreadyCurrent: true,
+          factoryId,
+          versionId: version.id,
+          restoredFromVersion: version.version,
+          graphVersion: definition.graphVersion,
+          name: definition.name,
+          graph: selectedGraph,
+          source: "restore" as const,
+        };
+      }
+
+      const nextVersion = definition.graphVersion + 1;
+      const restoredGraph = normalizeFactoryGraph({
+        ...selectedGraph,
+        version: nextVersion,
+      });
+      const now = new Date().toISOString();
+      const nextVersionId = stableId(
+        "factory-graph",
+        orgId,
+        factoryId,
+        String(nextVersion),
+      );
+      const changeSummary = `Restored version ${version.version}.`;
+
+      const updated = await tx
+        .update(factoryDefinitions)
+        .set({
+          name: restoredGraph.name,
+          description: restoredGraph.description,
+          graphVersion: nextVersion,
+          graphJson: JSON.stringify(restoredGraph),
+          updatedAt: now,
+          ownerEmail: userEmail,
+        })
+        .where(
+          and(
+            eq(factoryDefinitions.id, factoryId),
+            eq(factoryDefinitions.orgId, orgId),
+            eq(factoryDefinitions.graphVersion, definition.graphVersion),
+          ),
+        )
+        .returning({ id: factoryDefinitions.id });
+      if (updated.length === 0) {
+        throw new Error(
+          "Factory changed while restoring. Refresh history and try again.",
+        );
+      }
+
+      await tx.insert(factoryGraphVersions).values({
+        id: nextVersionId,
+        factoryId,
+        version: nextVersion,
+        graphJson: JSON.stringify(restoredGraph),
+        source: "restore",
+        changeSummary,
+        createdAt: now,
+        createdBy: userEmail,
+        ownerEmail: userEmail,
+        orgId,
+      });
+
+      return {
+        ok: true,
+        alreadyCurrent: false,
+        factoryId,
+        versionId: nextVersionId,
+        restoredFromVersion: version.version,
+        graphVersion: nextVersion,
+        name: restoredGraph.name,
+        graph: restoredGraph,
+        source: "restore" as const,
+      };
+    });
+  },
+});

package/corpus/templates/factory/actions/save-factory-graph.ts

@@ -12,10 +12,7 @@ import {
   factoryGraphSchema,
   normalizeFactoryGraph,
 } from "../server/factory-graph/contracts.js";
-import {
-  DEFAULT_FACTORY_ID,
-  readFactoryDefinition,
-} from "../server/factory-graph/store.js";
+import { DEFAULT_FACTORY_ID } from "../server/factory-graph/store.js";
 import {
   requireWorkspaceMember,
   workspaceMemberIdentityFromContext,
@@ -24,7 +21,7 @@ import { stableId } from "../server/triage/ids.js";
 
 export default defineAction({
   description:
-    "Create or update a Factory's versioned visual graph. Use source=ai for an agent-proposed graph and source=manual for a direct editor save. This changes configuration only; it never starts provider work.",
+    "Create or update a Factory's versioned visual graph. Pass expectedGraphVersion from the graph you inspected so stale edits are rejected. Use source=ai for an agent-proposed graph and source=manual for a direct editor save. This changes configuration only; it never starts provider work.",
   schema: z.object({
     factoryId: z
       .string()
@@ -38,6 +35,7 @@ export default defineAction({
     prompt: z.string().trim().max(10_000).default(""),
     source: z.enum(["manual", "ai", "seed"]).default("manual"),
     changeSummary: z.string().trim().max(500).default(""),
+    expectedGraphVersion: z.coerce.number().int().nonnegative(),
     graph: factoryGraphSchema,
   }),
   link: ({ result }) => ({
@@ -49,81 +47,116 @@ export default defineAction({
     label: `Open ${result.name} in Factory`,
   }),
   run: async (
-    { factoryId, name, description, prompt, source, changeSummary, graph },
+    {
+      factoryId,
+      name,
+      description,
+      prompt,
+      source,
+      changeSummary,
+      expectedGraphVersion,
+      graph,
+    },
     context,
   ) => {
     const { userEmail, orgId } = await requireWorkspaceMember(
       workspaceMemberIdentityFromContext(context),
     );
     const db = getDb();
-    const existing = await readFactoryDefinition(orgId, factoryId);
-    const nextVersion = (existing?.graphVersion ?? 0) + 1;
-    const normalizedGraph = normalizeFactoryGraph({
-      ...graph,
-      version: nextVersion,
-      name,
-      description,
-    });
-    const now = new Date().toISOString();
-    const versionId = stableId(
-      "factory-graph",
-      orgId,
-      factoryId,
-      String(nextVersion),
-    );
 
-    await db.insert(factoryGraphVersions).values({
-      id: versionId,
-      factoryId,
-      version: nextVersion,
-      graphJson: JSON.stringify(normalizedGraph),
-      source,
-      changeSummary,
-      createdAt: now,
-      createdBy: userEmail,
-      ownerEmail: userEmail,
-      orgId,
-    });
+    return db.transaction(async (tx) => {
+      const existing = (
+        await tx
+          .select()
+          .from(factoryDefinitions)
+          .where(
+            and(
+              eq(factoryDefinitions.id, factoryId),
+              eq(factoryDefinitions.orgId, orgId),
+            ),
+          )
+          .limit(1)
+      )[0];
+      if ((existing?.graphVersion ?? 0) !== expectedGraphVersion) {
+        throw new Error(
+          "Factory changed while saving. Refresh the Factory and try again.",
+        );
+      }
+      const nextVersion = (existing?.graphVersion ?? 0) + 1;
+      const normalizedGraph = normalizeFactoryGraph({
+        ...graph,
+        version: nextVersion,
+        name,
+        description,
+      });
+      const now = new Date().toISOString();
+      const versionId = stableId(
+        "factory-graph",
+        orgId,
+        factoryId,
+        String(nextVersion),
+      );
 
-    if (existing) {
-      await db
-        .update(factoryDefinitions)
-        .set({
+      if (existing) {
+        const updated = await tx
+          .update(factoryDefinitions)
+          .set({
+            name,
+            description,
+            prompt,
+            graphVersion: nextVersion,
+            graphJson: JSON.stringify(normalizedGraph),
+            updatedAt: now,
+            ownerEmail: userEmail,
+          })
+          .where(
+            and(
+              eq(factoryDefinitions.id, factoryId),
+              eq(factoryDefinitions.orgId, orgId),
+              eq(factoryDefinitions.graphVersion, expectedGraphVersion),
+            ),
+          )
+          .returning({ id: factoryDefinitions.id });
+        if (updated.length === 0) {
+          throw new Error(
+            "Factory changed while saving. Refresh the Factory and try again.",
+          );
+        }
+      } else {
+        await tx.insert(factoryDefinitions).values({
+          id: factoryId,
           name,
           description,
           prompt,
           graphVersion: nextVersion,
           graphJson: JSON.stringify(normalizedGraph),
+          createdAt: now,
           updatedAt: now,
           ownerEmail: userEmail,
-        })
-        .where(
-          and(
-            eq(factoryDefinitions.id, factoryId),
-            eq(factoryDefinitions.orgId, orgId),
-          ),
-        );
-    } else {
-      await db.insert(factoryDefinitions).values({
-        id: factoryId,
-        name,
-        description,
-        prompt,
-        graphVersion: nextVersion,
+          orgId,
+        });
+      }
+
+      await tx.insert(factoryGraphVersions).values({
+        id: versionId,
+        factoryId,
+        version: nextVersion,
         graphJson: JSON.stringify(normalizedGraph),
+        source,
+        changeSummary,
         createdAt: now,
-        updatedAt: now,
+        createdBy: userEmail,
         ownerEmail: userEmail,
         orgId,
       });
-    }
 
-    return {
-      ok: true,
-      factoryId,
-      name,
-      graphVersion: nextVersion,
-      source,
-    };
+      return {
+        ok: true,
+        factoryId,
+        name,
+        graphVersion: nextVersion,
+        source,
+      };
+    });
   },
 });