potential fix for 404 and additional logs

Author: waleed

apps/sim/hooks/use-webhook-management.ts

@@ -55,11 +55,25 @@ export function useWebhookManagement({
   const webhookUrl = useMemo(() => {
     if (!webhookPath) {
       const baseUrl = getBaseUrl()
-      return `${baseUrl}/api/webhooks/trigger/${blockId}`
+      const url = `${baseUrl}/api/webhooks/trigger/${blockId}`
+      logger.debug('Webhook URL generated using blockId fallback', {
+        blockId,
+        url,
+        hasWebhookPath: false,
+        webhookId,
+      })
+      return url
     }
     const baseUrl = getBaseUrl()
-    return `${baseUrl}/api/webhooks/trigger/${webhookPath}`
-  }, [webhookPath, blockId])
+    const url = `${baseUrl}/api/webhooks/trigger/${webhookPath}`
+    logger.debug('Webhook URL generated using triggerPath', {
+      blockId,
+      triggerPath: webhookPath,
+      url,
+      webhookId,
+    })
+    return url
+  }, [webhookPath, blockId, webhookId])
 
   const [isSaving, setIsSaving] = useState(false)
 
@@ -81,16 +95,33 @@ export function useWebhookManagement({
     const currentlyLoading = store.loadingWebhooks.has(blockId)
     const alreadyChecked = store.checkedWebhooks.has(blockId)
     const currentWebhookId = store.getValue(blockId, 'webhookId')
+    const currentTriggerPath = store.getValue(blockId, 'triggerPath')
+
+    logger.debug('Webhook management check', {
+      blockId,
+      currentlyLoading,
+      alreadyChecked,
+      currentWebhookId,
+      currentTriggerPath,
+      workflowId,
+    })
 
     if (currentlyLoading) {
+      logger.debug('Skipping webhook fetch - already loading', { blockId })
       return
     }
 
     if (alreadyChecked && currentWebhookId) {
+      logger.debug('Skipping webhook fetch - already checked and has webhookId', {
+        blockId,
+        webhookId: currentWebhookId,
+        triggerPath: currentTriggerPath,
+      })
       return
     }
 
     if (alreadyChecked && !currentWebhookId) {
+      logger.debug('Removing from checkedWebhooks - was checked but no webhookId', { blockId })
       useSubBlockStore.setState((state) => {
         const newSet = new Set(state.checkedWebhooks)
         newSet.delete(blockId)
@@ -106,6 +137,7 @@ export function useWebhookManagement({
         return
       }
 
+      logger.debug('Starting webhook fetch', { blockId, workflowId })
       useSubBlockStore.setState((state) => ({
         loadingWebhooks: new Set([...state.loadingWebhooks, blockId]),
       }))
@@ -132,7 +164,24 @@ export function useWebhookManagement({
               const currentPath = useSubBlockStore.getState().getValue(blockId, 'triggerPath')
               if (webhook.path !== currentPath) {
                 useSubBlockStore.getState().setValue(blockId, 'triggerPath', webhook.path)
+                logger.debug('Webhook path updated from API', {
+                  blockId,
+                  oldPath: currentPath,
+                  newPath: webhook.path,
+                  webhookId: webhook.id,
+                })
+              } else {
+                logger.debug('Webhook path unchanged', {
+                  blockId,
+                  path: webhook.path,
+                  webhookId: webhook.id,
+                })
               }
+            } else {
+              logger.debug('Webhook loaded but has no path', {
+                blockId,
+                webhookId: webhook.id,
+              })
             }
 
             if (webhook.providerConfig) {

apps/sim/stores/workflows/subblock/store.ts

@@ -97,13 +97,53 @@ export const useSubBlockStore = create<SubBlockStore>()(
     },
 
     initializeFromWorkflow: (workflowId: string, blocks: Record<string, any>) => {
+      logger.debug('Initializing workflow values', {
+        workflowId,
+        blockCount: Object.keys(blocks).length,
+      })
       const values: Record<string, Record<string, any>> = {}
+      const existingWorkflowValues = get().workflowValues[workflowId] || {}
 
       Object.entries(blocks).forEach(([blockId, block]) => {
         values[blockId] = {}
         Object.entries(block.subBlocks || {}).forEach(([subBlockId, subBlock]) => {
           values[blockId][subBlockId] = (subBlock as SubBlockConfig).value
         })
+
+        const existingBlockValues = existingWorkflowValues[blockId] || {}
+        const hadTriggerPath =
+          existingBlockValues.triggerPath !== undefined && existingBlockValues.triggerPath !== null
+        const hadWebhookId =
+          existingBlockValues.webhookId !== undefined && existingBlockValues.webhookId !== null
+
+        if (hadTriggerPath) {
+          values[blockId].triggerPath = existingBlockValues.triggerPath
+          logger.debug('Preserved triggerPath during workflow initialization', {
+            workflowId,
+            blockId,
+            triggerPath: existingBlockValues.triggerPath,
+          })
+        }
+        if (hadWebhookId) {
+          values[blockId].webhookId = existingBlockValues.webhookId
+          logger.debug('Preserved webhookId during workflow initialization', {
+            workflowId,
+            blockId,
+            webhookId: existingBlockValues.webhookId,
+          })
+        }
+
+        // Log if trigger block is missing webhook state (for debugging)
+        const blockConfig = getBlock(block.type)
+        const isTriggerBlock =
+          blockConfig && (blockConfig.category === 'triggers' || block.triggerMode === true)
+        if (isTriggerBlock && !hadTriggerPath && !hadWebhookId) {
+          logger.debug('Trigger block has no preserved webhook state', {
+            workflowId,
+            blockId,
+            blockType: block.type,
+          })
+        }
       })
 
       set((state) => ({