chore: import upstream snapshot with attribution

apps/sim/lib/workspace-events/emitter.ts

@@ -0,0 +1,241 @@
+import { createLogger } from '@sim/logger'
+import { getActiveWorkflowContext } from '@sim/platform-authz/workflow'
+import { generateShortId } from '@sim/utils/id'
+import type { WorkflowExecutionLog } from '@/lib/logs/types'
+import {
+  isSimRuleEventType,
+  SIM_RULE_COOLDOWN_HOURS,
+  SIM_TRIGGER_PROVIDER,
+} from '@/lib/workspace-events/constants'
+import {
+  buildDeployEventPayload,
+  buildExecutionEventPayload,
+  buildUndeployEventPayload,
+} from '@/lib/workspace-events/payload'
+import { evaluateRule } from '@/lib/workspace-events/rules'
+import { claimCooldown, isWithinCooldown, readLastFiredAt } from '@/lib/workspace-events/state'
+import {
+  fetchSimTriggerSubscriptions,
+  parseSubscriptionConfig,
+} from '@/lib/workspace-events/subscriptions'
+import type {
+  ExecutionEventContext,
+  SimEventPayload,
+  SimSubscription,
+  SimSubscriptionConfig,
+} from '@/lib/workspace-events/types'
+
+const logger = createLogger('WorkspaceEventEmitter')
+
+const SIM_RULE_COOLDOWN_MS = SIM_RULE_COOLDOWN_HOURS * 60 * 60 * 1000
+
+/** Stable cooldown identity for a subscriber block, surviving redeploys. */
+function subscriptionBlockKey(subscription: SimSubscription): string {
+  return subscription.webhook.blockId ?? subscription.webhook.path ?? ''
+}
+
+/**
+ * Enqueues one side-effect workflow execution for a matched subscription.
+ *
+ * Routes through the shared polled-webhook pipeline, which provides admission
+ * control, billing attribution, deployment checks, and queue-vs-inline
+ * routing. The processor stack (executor, blocks) is imported lazily so this
+ * module stays cheap for the execution logger to import.
+ */
+export async function dispatchSimEvent(
+  subscription: SimSubscription,
+  payload: SimEventPayload
+): Promise<void> {
+  const requestId = generateShortId()
+  try {
+    const { processPolledWebhookEvent } = await import('@/lib/webhooks/processor')
+    const result = await processPolledWebhookEvent(
+      subscription.webhook,
+      subscription.workflow,
+      payload,
+      requestId
+    )
+
+    if (!result.success) {
+      logger.error(
+        `[${requestId}] Failed to fire sim trigger for workflow ${subscription.workflow.id}:`,
+        result.statusCode,
+        result.error
+      )
+    }
+  } catch (error) {
+    logger.error(
+      `[${requestId}] Error firing sim trigger for workflow ${subscription.workflow.id}:`,
+      error
+    )
+  }
+}
+
+/** Workflow-scope filter shared by all event kinds. Empty selection watches every workflow. */
+function matchesWorkflowScope(config: SimSubscriptionConfig, sourceWorkflowId: string): boolean {
+  if (config.workflowIds.length === 0) return true
+  return config.workflowIds.includes(sourceWorkflowId)
+}
+
+/**
+ * Emits workspace events for a completed workflow execution.
+ *
+ * Fire-and-forget: errors are logged and never thrown, so event emission can
+ * never break the source execution. Executions started by the Sim trigger
+ * itself never emit (loop prevention).
+ */
+export async function emitExecutionCompletedEvent(log: WorkflowExecutionLog): Promise<void> {
+  try {
+    if (!log.workflowId) return
+    if (log.trigger === SIM_TRIGGER_PROVIDER) return
+
+    const workflowContext = await getActiveWorkflowContext(log.workflowId)
+    if (!workflowContext?.workspaceId) return
+
+    const subscriptions = await fetchSimTriggerSubscriptions(workflowContext.workspaceId)
+    if (subscriptions.length === 0) return
+
+    const executionData = (log.executionData ?? {}) as Record<string, unknown>
+    const context: ExecutionEventContext = {
+      workflowId: log.workflowId,
+      executionId: log.executionId,
+      status: log.level === 'error' ? 'error' : 'success',
+      durationMs: log.totalDurationMs || 0,
+      cost: (log.cost as { total?: number } | undefined)?.total || 0,
+      finalOutput: executionData.finalOutput,
+    }
+
+    for (const subscription of subscriptions) {
+      const config = parseSubscriptionConfig(subscription.webhook.providerConfig)
+      if (!config) continue
+      if (config.eventType === 'workflow_deployed') continue
+      // no_activity is owned by the inactivity poller and can never fire from
+      // a completed execution; skip before the rule branch costs a cooldown
+      // read on this hot path.
+      if (config.eventType === 'no_activity') continue
+
+      if (subscription.webhook.workflowId === log.workflowId) continue
+      if (!matchesWorkflowScope(config, log.workflowId)) continue
+
+      if (config.eventType === 'execution_success' && context.status !== 'success') continue
+      if (config.eventType === 'execution_error' && context.status !== 'error') continue
+
+      if (isSimRuleEventType(config.eventType)) {
+        const blockKey = subscriptionBlockKey(subscription)
+
+        const lastFiredAt = await readLastFiredAt(subscription.webhook.workflowId, blockKey, '')
+        if (isWithinCooldown(lastFiredAt, SIM_RULE_COOLDOWN_MS)) continue
+
+        const ruleFired = await evaluateRule(config.eventType, config, context)
+        if (!ruleFired) continue
+
+        const claimed = await claimCooldown(
+          subscription.webhook.workflowId,
+          blockKey,
+          '',
+          SIM_RULE_COOLDOWN_MS
+        )
+        if (!claimed) continue
+
+        logger.info(`Sim trigger rule ${config.eventType} fired`, {
+          subscriberWorkflowId: subscription.webhook.workflowId,
+          sourceWorkflowId: log.workflowId,
+          executionId: log.executionId,
+        })
+      }
+
+      const payload = buildExecutionEventPayload({
+        event: config.eventType as Parameters<typeof buildExecutionEventPayload>[0]['event'],
+        workflowName: workflowContext.workflow.name,
+        context,
+      })
+
+      await dispatchSimEvent(subscription, payload)
+    }
+  } catch (error) {
+    logger.error('Failed to emit workspace execution event', {
+      error,
+      workflowId: log.workflowId,
+      executionId: log.executionId,
+    })
+  }
+}
+
+/**
+ * Shared dispatch loop for workflow lifecycle events: matches subscriptions
+ * on event type and workflow scope, never notifying the source workflow about
+ * itself. Fire-and-forget: failures never affect the lifecycle operation.
+ */
+async function emitWorkflowLifecycleEvent(params: {
+  eventType: 'workflow_deployed' | 'workflow_undeployed'
+  workflowId: string
+  workspaceId: string
+  payload: SimEventPayload
+}): Promise<void> {
+  try {
+    const subscriptions = await fetchSimTriggerSubscriptions(params.workspaceId)
+    if (subscriptions.length === 0) return
+
+    for (const subscription of subscriptions) {
+      const config = parseSubscriptionConfig(subscription.webhook.providerConfig)
+      if (!config) continue
+      if (config.eventType !== params.eventType) continue
+
+      if (subscription.webhook.workflowId === params.workflowId) continue
+      if (!matchesWorkflowScope(config, params.workflowId)) continue
+
+      await dispatchSimEvent(subscription, params.payload)
+    }
+  } catch (error) {
+    logger.error(`Failed to emit ${params.eventType} event`, {
+      error,
+      workflowId: params.workflowId,
+    })
+  }
+}
+
+/**
+ * Emits a workflow_deployed event to subscribed side-effect workflows.
+ *
+ * Fired on any deployment activation (fresh deploy, redeploy, version
+ * rollback/activation). Fire-and-forget: failures never affect the deploy.
+ */
+export async function emitWorkflowDeployedEvent(params: {
+  workflowId: string
+  workflowName: string
+  workspaceId: string
+  version: number | null
+}): Promise<void> {
+  await emitWorkflowLifecycleEvent({
+    eventType: 'workflow_deployed',
+    workflowId: params.workflowId,
+    workspaceId: params.workspaceId,
+    payload: buildDeployEventPayload({
+      workflowId: params.workflowId,
+      workflowName: params.workflowName,
+      version: params.version,
+    }),
+  })
+}
+
+/**
+ * Emits a workflow_undeployed event to subscribed side-effect workflows.
+ *
+ * Fired when a workflow is taken offline. Fire-and-forget: failures never
+ * affect the undeploy.
+ */
+export async function emitWorkflowUndeployedEvent(params: {
+  workflowId: string
+  workflowName: string
+  workspaceId: string
+}): Promise<void> {
+  await emitWorkflowLifecycleEvent({
+    eventType: 'workflow_undeployed',
+    workflowId: params.workflowId,
+    workspaceId: params.workspaceId,
+    payload: buildUndeployEventPayload({
+      workflowId: params.workflowId,
+      workflowName: params.workflowName,
+    }),
+  })
+}