cleanup code

Author: icecrasher321

apps/sim/app/api/workflows/[id]/deployments/[version]/revert/route.ts

@@ -97,7 +97,10 @@ export async function POST(
       const socketServerUrl = env.SOCKET_SERVER_URL || 'http://localhost:3002'
       await fetch(`${socketServerUrl}/api/workflow-reverted`, {
         method: 'POST',
-        headers: { 'Content-Type': 'application/json' },
+        headers: {
+          'Content-Type': 'application/json',
+          'x-api-key': env.INTERNAL_API_SECRET,
+        },
         body: JSON.stringify({ workflowId: id, timestamp: Date.now() }),
       })
     } catch (e) {

apps/sim/app/api/workflows/[id]/route.ts

@@ -361,7 +361,10 @@ export async function DELETE(
       const socketUrl = env.SOCKET_SERVER_URL || 'http://localhost:3002'
       const socketResponse = await fetch(`${socketUrl}/api/workflow-deleted`, {
         method: 'POST',
-        headers: { 'Content-Type': 'application/json' },
+        headers: {
+          'Content-Type': 'application/json',
+          'x-api-key': env.INTERNAL_API_SECRET,
+        },
         body: JSON.stringify({ workflowId }),
       })
 

apps/sim/app/api/workflows/[id]/state/route.ts

@@ -254,7 +254,10 @@ export async function PUT(request: NextRequest, { params }: { params: Promise<{
       const socketUrl = env.SOCKET_SERVER_URL || 'http://localhost:3002'
       const notifyResponse = await fetch(`${socketUrl}/api/workflow-updated`, {
         method: 'POST',
-        headers: { 'Content-Type': 'application/json' },
+        headers: {
+          'Content-Type': 'application/json',
+          'x-api-key': env.INTERNAL_API_SECRET,
+        },
         body: JSON.stringify({ workflowId }),
       })
 

apps/sim/app/workspace/providers/socket-provider.tsx

@@ -322,6 +322,11 @@ export function SocketProvider({ children, user }: SocketProviderProps) {
         // Handle join workflow success - confirms room membership with presence list
         socketInstance.on('join-workflow-success', ({ workflowId, presenceUsers }) => {
           isRejoiningRef.current = false
+          // Ignore stale success responses from previous navigation
+          if (workflowId !== urlWorkflowIdRef.current) {
+            logger.debug(`Ignoring stale join-workflow-success for ${workflowId}`)
+            return
+          }
           setCurrentWorkflowId(workflowId)
           setPresenceUsers(presenceUsers || [])
           logger.info(`Successfully joined workflow room: ${workflowId}`, {
@@ -516,7 +521,11 @@ export function SocketProvider({ children, user }: SocketProviderProps) {
           logger.info('Received workflow state from server')
 
           if (workflowData?.state) {
-            await rehydrateWorkflowStores(workflowData.id, workflowData.state, 'workflow-state')
+            try {
+              await rehydrateWorkflowStores(workflowData.id, workflowData.state, 'workflow-state')
+            } catch (error) {
+              logger.error('Error rehydrating workflow state:', error)
+            }
           }
         })
 
@@ -598,10 +607,13 @@ export function SocketProvider({ children, user }: SocketProviderProps) {
   const leaveWorkflow = useCallback(() => {
     if (socket && currentWorkflowId) {
       logger.info(`Leaving workflow: ${currentWorkflowId}`)
-      try {
-        const { useOperationQueueStore } = require('@/stores/operation-queue/store')
-        useOperationQueueStore.getState().cancelOperationsForWorkflow(currentWorkflowId)
-      } catch {}
+      import('@/stores/operation-queue/store')
+        .then(({ useOperationQueueStore }) => {
+          useOperationQueueStore.getState().cancelOperationsForWorkflow(currentWorkflowId)
+        })
+        .catch((error) => {
+          logger.warn('Failed to cancel operations for workflow:', error)
+        })
       socket.emit('leave-workflow')
       setCurrentWorkflowId(null)
       setPresenceUsers([])

apps/sim/socket/config/socket.ts

@@ -9,6 +9,13 @@ import { getBaseUrl } from '@/lib/core/utils/urls'
 
 const logger = createLogger('SocketIOConfig')
 
+/** Socket.IO ping timeout - how long to wait for pong before considering connection dead */
+const PING_TIMEOUT_MS = 60000
+/** Socket.IO ping interval - how often to send ping packets */
+const PING_INTERVAL_MS = 25000
+/** Maximum HTTP buffer size for Socket.IO messages */
+const MAX_HTTP_BUFFER_SIZE = 1e6
+
 let adapterPubClient: RedisClientType | null = null
 let adapterSubClient: RedisClientType | null = null
 
@@ -41,9 +48,9 @@ export async function createSocketIOServer(httpServer: HttpServer): Promise<Serv
     },
     transports: ['websocket', 'polling'],
     allowEIO3: true,
-    pingTimeout: 60000,
-    pingInterval: 25000,
-    maxHttpBufferSize: 1e6,
+    pingTimeout: PING_TIMEOUT_MS,
+    pingInterval: PING_INTERVAL_MS,
+    maxHttpBufferSize: MAX_HTTP_BUFFER_SIZE,
     cookie: {
       name: 'io',
       path: '/',
@@ -103,9 +110,9 @@ export async function createSocketIOServer(httpServer: HttpServer): Promise<Serv
   logger.info('Socket.IO server configured with:', {
     allowedOrigins: allowedOrigins.length,
     transports: ['websocket', 'polling'],
-    pingTimeout: 60000,
-    pingInterval: 25000,
-    maxHttpBufferSize: 1e6,
+    pingTimeout: PING_TIMEOUT_MS,
+    pingInterval: PING_INTERVAL_MS,
+    maxHttpBufferSize: MAX_HTTP_BUFFER_SIZE,
     cookieSecure: isProd,
     corsCredentials: true,
     redisAdapter: !!env.REDIS_URL,

apps/sim/socket/handlers/operations.ts

@@ -23,19 +23,28 @@ export function setupOperationsHandlers(socket: AuthenticatedSocket, roomManager
     const session = await roomManager.getUserSession(socket.id)
 
     if (!workflowId || !session) {
-      socket.emit('error', {
-        type: 'NOT_JOINED',
-        message: 'Not joined to any workflow',
+      socket.emit('operation-forbidden', {
+        type: 'SESSION_ERROR',
+        message: 'Session expired, please rejoin workflow',
       })
+      if (data?.operationId) {
+        socket.emit('operation-failed', { operationId: data.operationId, error: 'Session expired' })
+      }
       return
     }
 
     const hasRoom = await roomManager.hasWorkflowRoom(workflowId)
     if (!hasRoom) {
-      socket.emit('error', {
+      socket.emit('operation-forbidden', {
         type: 'ROOM_NOT_FOUND',
         message: 'Workflow room not found',
       })
+      if (data?.operationId) {
+        socket.emit('operation-failed', {
+          operationId: data.operationId,
+          error: 'Workflow room not found',
+        })
+      }
       return
     }
 

apps/sim/socket/handlers/subblocks.ts

@@ -7,6 +7,9 @@ import type { IRoomManager } from '@/socket/rooms'
 
 const logger = createLogger('SubblocksHandlers')
 
+/** Debounce interval for coalescing rapid subblock updates before persisting */
+const DEBOUNCE_INTERVAL_MS = 25
+
 type PendingSubblock = {
   latest: { blockId: string; subblockId: string; value: any; timestamp: number }
   timeout: NodeJS.Timeout
@@ -22,7 +25,7 @@ const pendingSubblockUpdates = new Map<string, PendingSubblock>()
  * Removes the socket's operationIds from pending updates to prevent memory leaks.
  */
 export function cleanupPendingSubblocksForSocket(socketId: string): void {
-  for (const [key, pending] of pendingSubblockUpdates.entries()) {
+  for (const [, pending] of pendingSubblockUpdates.entries()) {
     // Remove this socket's operation entries
     for (const [opId, sid] of pending.opToSocket.entries()) {
       if (sid === socketId) {
@@ -52,6 +55,9 @@ export function setupSubblocksHandlers(socket: AuthenticatedSocket, roomManager:
           type: 'SESSION_ERROR',
           message: 'Session expired, please rejoin workflow',
         })
+        if (operationId) {
+          socket.emit('operation-failed', { operationId, error: 'Session expired' })
+        }
         return
       }
 
@@ -79,7 +85,7 @@ export function setupSubblocksHandlers(socket: AuthenticatedSocket, roomManager:
         existing.timeout = setTimeout(async () => {
           await flushSubblockUpdate(workflowId, existing, roomManager)
           pendingSubblockUpdates.delete(debouncedKey)
-        }, 25)
+        }, DEBOUNCE_INTERVAL_MS)
       } else {
         const opToSocket = new Map<string, string>()
         if (operationId) opToSocket.set(operationId, socket.id)
@@ -89,7 +95,7 @@ export function setupSubblocksHandlers(socket: AuthenticatedSocket, roomManager:
             await flushSubblockUpdate(workflowId, pending, roomManager)
             pendingSubblockUpdates.delete(debouncedKey)
           }
-        }, 25)
+        }, DEBOUNCE_INTERVAL_MS)
         pendingSubblockUpdates.set(debouncedKey, {
           latest: { blockId, subblockId, value, timestamp },
           timeout,

apps/sim/socket/handlers/variables.ts

@@ -7,6 +7,9 @@ import type { IRoomManager } from '@/socket/rooms'
 
 const logger = createLogger('VariablesHandlers')
 
+/** Debounce interval for coalescing rapid variable updates before persisting */
+const DEBOUNCE_INTERVAL_MS = 25
+
 type PendingVariable = {
   latest: { variableId: string; field: string; value: any; timestamp: number }
   timeout: NodeJS.Timeout
@@ -21,7 +24,7 @@ const pendingVariableUpdates = new Map<string, PendingVariable>()
  * Removes the socket's operationIds from pending updates to prevent memory leaks.
  */
 export function cleanupPendingVariablesForSocket(socketId: string): void {
-  for (const [key, pending] of pendingVariableUpdates.entries()) {
+  for (const [, pending] of pendingVariableUpdates.entries()) {
     for (const [opId, sid] of pending.opToSocket.entries()) {
       if (sid === socketId) {
         pending.opToSocket.delete(opId)
@@ -48,6 +51,9 @@ export function setupVariablesHandlers(socket: AuthenticatedSocket, roomManager:
           type: 'SESSION_ERROR',
           message: 'Session expired, please rejoin workflow',
         })
+        if (operationId) {
+          socket.emit('operation-failed', { operationId, error: 'Session expired' })
+        }
         return
       }
 
@@ -74,7 +80,7 @@ export function setupVariablesHandlers(socket: AuthenticatedSocket, roomManager:
         existing.timeout = setTimeout(async () => {
           await flushVariableUpdate(workflowId, existing, roomManager)
           pendingVariableUpdates.delete(debouncedKey)
-        }, 25)
+        }, DEBOUNCE_INTERVAL_MS)
       } else {
         const opToSocket = new Map<string, string>()
         if (operationId) opToSocket.set(operationId, socket.id)
@@ -84,7 +90,7 @@ export function setupVariablesHandlers(socket: AuthenticatedSocket, roomManager:
             await flushVariableUpdate(workflowId, pending, roomManager)
             pendingVariableUpdates.delete(debouncedKey)
           }
-        }, 25)
+        }, DEBOUNCE_INTERVAL_MS)
         pendingVariableUpdates.set(debouncedKey, {
           latest: { variableId, field, value, timestamp },
           timeout,

apps/sim/socket/index.ts

@@ -10,6 +10,9 @@ import { createHttpHandler } from '@/socket/routes/http'
 
 const logger = createLogger('CollaborativeSocketServer')
 
+/** Maximum time to wait for graceful shutdown before forcing exit */
+const SHUTDOWN_TIMEOUT_MS = 10000
+
 async function createRoomManager(io: SocketIOServer): Promise<IRoomManager> {
   if (env.REDIS_URL) {
     logger.info('Initializing Redis-backed RoomManager for multi-pod support')
@@ -108,7 +111,7 @@ async function main() {
     setTimeout(() => {
       logger.error('Forced shutdown after timeout')
       process.exit(1)
-    }, 10000)
+    }, SHUTDOWN_TIMEOUT_MS)
   }
 
   process.on('SIGINT', shutdown)

apps/sim/socket/middleware/auth.ts

@@ -21,7 +21,7 @@ export interface AuthenticatedSocket extends Socket {
  * Socket.IO authentication middleware.
  * Handles both anonymous mode (DISABLE_AUTH=true) and normal token-based auth.
  */
-export async function authenticateSocket(socket: AuthenticatedSocket, next: any) {
+export async function authenticateSocket(socket: AuthenticatedSocket, next: (err?: Error) => void) {
   try {
     if (isAuthDisabled) {
       socket.userId = ANONYMOUS_USER_ID