fix webhook stability issues + drift detection removal

Author: icecrasher321

apps/sim/app/api/workspaces/[id]/fork/diff/route.ts

@@ -6,8 +6,10 @@ import { getSession } from '@/lib/auth'
 import { withRouteHandler } from '@/lib/core/utils/with-route-handler'
 import { loadSourceDeployedStates } from '@/lib/workspaces/fork/copy/deploy-bridge'
 import { assertCanPromote } from '@/lib/workspaces/fork/lineage/authz'
+import { loadForkBlockMap } from '@/lib/workspaces/fork/mapping/block-map-store'
 import { collectForkDependentReconfigs } from '@/lib/workspaces/fork/mapping/dependent-reconfigs'
 import { computeForkPromotePlan } from '@/lib/workspaces/fork/promote/promote-plan'
+import { buildForkBlockIdResolver } from '@/lib/workspaces/fork/remap/block-identity'
 
 export const GET = withRouteHandler(
   async (req: NextRequest, context: { params: Promise<{ id: string }> }) => {
@@ -36,6 +38,13 @@ export const GET = withRouteHandler(
       sourceStates,
     })
 
+    // Resolve dependent-reconfig target block ids through the SAME persisted block map the
+    // sync will use, so a re-pick the modal keys by target block id lands on the block the
+    // promote actually writes (on push that's the parent's original id, not a derived one).
+    const sourceIsParent = auth.sourceWorkspaceId === auth.edge.parentWorkspaceId
+    const blockMap = await loadForkBlockMap(db, auth.edge.childWorkspaceId)
+    const resolveBlockId = buildForkBlockIdResolver(sourceIsParent, blockMap)
+
     const toRef = (reference: (typeof plan.unmappedRequired)[number]) => ({
       kind: reference.kind,
       sourceId: reference.sourceId,
@@ -81,8 +90,7 @@ export const GET = withRouteHandler(
       unmappedOptional: plan.unmappedOptional.map(toRef),
       mcpReauthServerIds: plan.mcpReauthServerIds,
       inlineSecretSources: plan.inlineSecretSources,
-      dependentReconfigs: collectForkDependentReconfigs(plan.items, sourceStates),
-      drift: plan.drift,
+      dependentReconfigs: collectForkDependentReconfigs(plan.items, sourceStates, resolveBlockId),
     })
   }
 )

apps/sim/app/api/workspaces/[id]/fork/promote/route.ts

@@ -25,7 +25,7 @@ export const POST = withRouteHandler(
     const parsed = await parseRequest(promoteForkContract, req, context)
     if (!parsed.success) return parsed.response
     const { id } = parsed.data.params
-    const { otherWorkspaceId, direction, force, dependentOverrides } = parsed.data.body
+    const { otherWorkspaceId, direction, dependentOverrides } = parsed.data.body
 
     const auth = await assertCanPromote(id, otherWorkspaceId, direction, session.user.id)
 
@@ -34,7 +34,6 @@ export const POST = withRouteHandler(
       sourceWorkspaceId: auth.sourceWorkspaceId,
       targetWorkspaceId: auth.targetWorkspaceId,
       direction,
-      force,
       userId: session.user.id,
       dependentOverrides,
       requestId,
@@ -50,7 +49,6 @@ export const POST = withRouteHandler(
       unmappedRequired: result.unmappedRequired,
       needsConfiguration: result.needsConfiguration,
       clearedOptional: result.clearedOptional,
-      drift: result.drift,
     }
 
     if (result.blocked) {

apps/sim/app/workspace/[workspaceId]/w/components/sidebar/components/workspace-header/components/promote-workspace-modal/promote-workspace-modal.tsx

@@ -128,7 +128,7 @@ interface EdgeOption {
  * picks a direction and lists each resource kind's mapping status, then Sync.
  * "Edit mappings" steps through every kind (Back/Next, each source a
  * settings-style section + full-width target) to set or review targets before
- * landing back on Sync - with a force-confirm on drift. The durable record of
+ * landing back on Sync - which always confirms the overwrite first. The durable record of
  * every sync is the Activity log in Manage Forks, so this modal just closes on
  * success.
  */
@@ -173,7 +173,7 @@ export function PromoteWorkspaceModal({
   // Wizard step: 0 is the overview; 1..N edit one resource kind each, entered via
   // "Edit mappings". Backing out of step 1 returns to the overview.
   const [step, setStep] = useState(0)
-  const [confirmDriftOpen, setConfirmDriftOpen] = useState(false)
+  const [confirmSyncOpen, setConfirmSyncOpen] = useState(false)
   const [submitting, setSubmitting] = useState(false)
 
   useEffect(() => {
@@ -289,7 +289,7 @@ export function PromoteWorkspaceModal({
     (diff.data?.mcpReauthServerIds.length ?? 0) > 0 ||
     (diff.data?.inlineSecretSources.length ?? 0) > 0
 
-  const runPromote = async (force: boolean) => {
+  const runPromote = async () => {
     if (!otherWorkspaceId) return
     setSubmitting(true)
     try {
@@ -328,7 +328,6 @@ export function PromoteWorkspaceModal({
         body: {
           otherWorkspaceId,
           direction,
-          force,
           ...(dependentOverrides.length > 0 ? { dependentOverrides } : {}),
         },
       })
@@ -338,10 +337,6 @@ export function PromoteWorkspaceModal({
           toast.error('Map all required credentials and secrets first')
           return
         }
-        if (result.drift) {
-          setConfirmDriftOpen(true)
-          return
-        }
         toast.error('Sync did not complete')
         return
       }
@@ -638,7 +633,7 @@ export function PromoteWorkspaceModal({
               ? { label: 'Next', onClick: () => setStep(safeStep + 1), disabled: submitting }
               : {
                   label: submitting ? 'Working...' : 'Sync',
-                  onClick: () => void runPromote(false),
+                  onClick: () => setConfirmSyncOpen(true),
                   disabled: syncDisabled,
                   disabledTooltip: !requiredComplete
                     ? 'Map all required secrets first'
@@ -651,20 +646,20 @@ export function PromoteWorkspaceModal({
       </ChipModal>
 
       <ChipConfirmModal
-        open={confirmDriftOpen}
-        onOpenChange={setConfirmDriftOpen}
-        srTitle='Force sync'
-        title='Target has changed'
+        open={confirmSyncOpen}
+        onOpenChange={setConfirmSyncOpen}
+        srTitle='Sync workspace'
+        title='Overwrite target workspace'
         text={[
-          'The target workspace was modified since the last sync. Force syncing will ',
-          { text: 'overwrite those changes', bold: true },
-          '. Continue?',
+          'The target may have been modified since the last sync. Syncing will ',
+          { text: 'overwrite any changes', bold: true },
+          ' there. Continue?',
         ]}
         confirm={{
-          label: 'Force sync',
+          label: 'Sync',
           onClick: () => {
-            setConfirmDriftOpen(false)
-            void runPromote(true)
+            setConfirmSyncOpen(false)
+            void runPromote()
           },
           pending: submitting,
           pendingLabel: 'Syncing...',

apps/sim/lib/api/contracts/workspace-fork.ts

@@ -283,7 +283,6 @@ export const getForkDiffContract = defineRouteContract({
       inlineSecretSources: z.array(z.string()),
       /** Configured selector fields per parent (credential/KB), for the pre-sync reconfigure. */
       dependentReconfigs: z.array(forkDependentReconfigSchema),
-      drift: z.boolean(),
     }),
   },
 })
@@ -320,7 +319,6 @@ export type ForkDependentOverride = z.input<typeof forkDependentOverrideSchema>
 export const promoteForkBodySchema = z.object({
   otherWorkspaceId: workspaceIdSchema,
   direction: forkDirectionSchema,
-  force: z.boolean().optional().default(false),
   /** Pre-sync re-picks for dependent fields whose credential the user swapped. */
   dependentOverrides: z.array(forkDependentOverrideSchema).max(2000).optional(),
 })
@@ -343,7 +341,6 @@ export const promoteForkContract = defineRouteContract({
       needsConfiguration: z.array(forkNeedsConfigurationSchema),
       /** Workflows whose optional dependent fields a swap cleared (surfaced, not gated). */
       clearedOptional: z.array(forkNeedsConfigurationSchema),
-      drift: z.boolean(),
     }),
   },
 })

apps/sim/lib/workspaces/fork/copy/copy-workflows.ts

@@ -12,7 +12,10 @@ import {
   sanitizeSubBlocksForDuplicate,
 } from '@/lib/workflows/persistence/remap-internal-ids'
 import { saveWorkflowToNormalizedTables } from '@/lib/workflows/persistence/utils'
-import { deriveForkBlockId } from '@/lib/workspaces/fork/remap/block-identity'
+import {
+  deriveForkBlockId,
+  type ForkBlockIdResolver,
+} from '@/lib/workspaces/fork/remap/block-identity'
 import {
   applyDependentOverrides,
   collectClearedDependents,
@@ -257,6 +260,11 @@ export interface CopyWorkflowResult {
    * surfaces optional ones so a cleared filter never broadens behavior silently.
    */
   clearedDependents: NeedsConfigurationField[]
+  /**
+   * Source block id -> assigned target block id, so the caller can persist the
+   * block-identity pairs (see `recordForkBlockPairs`) that keep promotes reversible.
+   */
+  blockIdMapping: Map<string, string>
 }
 
 export interface CopyWorkflowStateParams {
@@ -299,6 +307,13 @@ export interface CopyWorkflowStateParams {
    * query per workflow inside the tx. Build once per copy loop via {@link loadWorkflowNameRegistry}.
    */
   nameRegistry: WorkflowNameRegistry
+  /**
+   * Resolve each source block to its target block id, reusing the persisted counterpart
+   * when one exists so a push keeps the parent's original block ids (and webhook URLs)
+   * instead of re-deriving them (see {@link buildForkBlockIdResolver}). Omitted on fork
+   * creation, where every id is derived fresh.
+   */
+  resolveBlockId?: ForkBlockIdResolver
   requestId?: string
 }
 
@@ -330,6 +345,7 @@ export async function copyWorkflowStateIntoTarget(
     targetCurrentBlocks,
     dependentOverrides,
     nameRegistry,
+    resolveBlockId,
     requestId = 'unknown',
   } = params
 
@@ -345,7 +361,12 @@ export async function copyWorkflowStateIntoTarget(
 
   const blockIdMapping = new Map<string, string>()
   for (const oldBlockId of Object.keys(sourceState.blocks)) {
-    blockIdMapping.set(oldBlockId, deriveForkBlockId(targetWorkflowId, oldBlockId))
+    blockIdMapping.set(
+      oldBlockId,
+      resolveBlockId
+        ? resolveBlockId(targetWorkflowId, oldBlockId)
+        : deriveForkBlockId(targetWorkflowId, oldBlockId)
+    )
   }
 
   const newBlocks: Record<string, BlockState> = {}
@@ -526,5 +547,6 @@ export async function copyWorkflowStateIntoTarget(
     edgesCount: newEdges.length,
     subflowsCount: Object.keys(newLoops).length + Object.keys(newParallels).length,
     clearedDependents,
+    blockIdMapping,
   }
 }

apps/sim/lib/workspaces/fork/create-fork.ts

@@ -30,6 +30,11 @@ import {
 } from '@/lib/workspaces/fork/copy/copy-workflows'
 import { loadSourceDeployedStates } from '@/lib/workspaces/fork/copy/deploy-bridge'
 import { setForkLockTimeout } from '@/lib/workspaces/fork/lineage/lineage'
+import {
+  type ForkBlockPair,
+  reconcileForkBlockPairs,
+  toForkBlockPairs,
+} from '@/lib/workspaces/fork/mapping/block-map-store'
 import {
   type ForkMappingUpsert,
   type ForkResourceType,
@@ -212,12 +217,18 @@ export async function createFork(params: CreateForkParams): Promise<CreateForkRe
     const nameRegistry = await loadWorkflowNameRegistry(tx, childWorkspaceId)
 
     let workflowsCopied = 0
+    // Seed the block-identity map (parent block -> derived child block) so a later push of
+    // this fork resolves each child block back to the parent's ORIGINAL id instead of
+    // re-deriving and re-keying the parent's webhook URLs.
+    const blockPairs: ForkBlockPair[] = []
+    const sourceWorkflowIds: string[] = []
     for (const wf of deployedWorkflows) {
       const sourceState = sourceStates.get(wf.id)
       if (!sourceState) continue
-      await copyWorkflowStateIntoTarget({
+      const targetWorkflowId = workflowIdMap.get(wf.id)!
+      const copyResult = await copyWorkflowStateIntoTarget({
         tx,
-        targetWorkflowId: workflowIdMap.get(wf.id)!,
+        targetWorkflowId,
         targetWorkspaceId: childWorkspaceId,
         userId,
         mode: 'create',
@@ -235,9 +246,13 @@ export async function createFork(params: CreateForkParams): Promise<CreateForkRe
         nameRegistry,
         requestId,
       })
+      // Creation copies parent -> child, so the source side is the parent.
+      blockPairs.push(...toForkBlockPairs(copyResult.blockIdMapping, true, wf.id, targetWorkflowId))
+      sourceWorkflowIds.push(wf.id)
       workflowsCopied += 1
       forkedWorkflowNames.push(wf.name)
     }
+    await reconcileForkBlockPairs(tx, childWorkspaceId, true, sourceWorkflowIds, blockPairs)
 
     // A fork carries only DEPLOYED workflows. When the source has none (e.g. it was
     // itself just forked and never redeployed), seed a default workflow so the child

apps/sim/lib/workspaces/fork/mapping/block-map-store.test.ts

@@ -0,0 +1,50 @@
+/**
+ * @vitest-environment node
+ */
+import { describe, expect, it } from 'vitest'
+import { toForkBlockPairs } from '@/lib/workspaces/fork/mapping/block-map-store'
+
+describe('toForkBlockPairs', () => {
+  const mapping = new Map([
+    ['src-1', 'tgt-1'],
+    ['src-2', 'tgt-2'],
+  ])
+
+  it('orients source->target as parent->child on pull/create (source = parent)', () => {
+    expect(toForkBlockPairs(mapping, true, 'wf-parent', 'wf-child')).toEqual([
+      {
+        parentWorkflowId: 'wf-parent',
+        childWorkflowId: 'wf-child',
+        parentBlockId: 'src-1',
+        childBlockId: 'tgt-1',
+      },
+      {
+        parentWorkflowId: 'wf-parent',
+        childWorkflowId: 'wf-child',
+        parentBlockId: 'src-2',
+        childBlockId: 'tgt-2',
+      },
+    ])
+  })
+
+  it('orients source->target as child->parent on push (source = child)', () => {
+    expect(toForkBlockPairs(mapping, false, 'wf-child', 'wf-parent')).toEqual([
+      {
+        parentWorkflowId: 'wf-parent',
+        childWorkflowId: 'wf-child',
+        parentBlockId: 'tgt-1',
+        childBlockId: 'src-1',
+      },
+      {
+        parentWorkflowId: 'wf-parent',
+        childWorkflowId: 'wf-child',
+        parentBlockId: 'tgt-2',
+        childBlockId: 'src-2',
+      },
+    ])
+  })
+
+  it('returns an empty list for an empty mapping', () => {
+    expect(toForkBlockPairs(new Map(), true, 'wf-parent', 'wf-child')).toEqual([])
+  })
+})