Skip to content

AI Agents & MCPs & AI Workflow Automation • (~400 MCP servers for AI agents) • AI Automation / AI Agent with MCPs • AI Workflows & AI Agents • MCPs for AI Agents

4.0 KB
Raw Blame
import { FlowId, FlowVersionId, isNil, ProjectId } from '@activepieces/core-utils'
import { EngineResponse, EngineResponseStatus, ExecuteTriggerResponse, TriggerHookType, TriggerPayload, TriggerSource, WebhookHandshakeConfiguration, WebhookHandshakeStrategy, WorkerJobType } from '@activepieces/shared'
import { FastifyBaseLogger } from 'fastify'
import { projectService } from '../project/project-service'
import { triggerUtils } from '../trigger/trigger-source/trigger-utils'
import { userInteractionWatcher } from '../workers/user-interaction-watcher'

export const webhookHandshake = {
    async handleHandshakeRequest(params: HandleHandshakeRequestParams): Promise<WebhookHandshakeResponse | null> {
        const { payload, handshakeConfiguration, logger } = params

        if (!isHandshakeRequest({ payload, handshakeConfiguration })) {
            return null
        }

        const platformId = await projectService(logger).getPlatformId(params.projectId)

        const engineHelperResponse = await userInteractionWatcher.submitAndWaitForResponse<EngineResponse<ExecuteTriggerResponse<TriggerHookType.HANDSHAKE>>>({
            jobType: WorkerJobType.EXECUTE_TRIGGER_HOOK,
            hookType: TriggerHookType.HANDSHAKE,
            flowId: params.flowId,
            flowVersionId: params.flowVersionId,
            projectId: params.projectId,
            test: false,
            platformId,
            triggerPayload: payload,
        }, logger)

        if (engineHelperResponse.status !== EngineResponseStatus.OK) {
            return null
        }
        return engineHelperResponse.response?.response ?? null
    },
    async getWebhookHandshakeConfiguration(params: GetWebhookHandshakeConfigurationParams): Promise<WebhookHandshakeConfiguration | null> {
        const { triggerSource, logger } = params
        if (isNil(triggerSource) || isNil(triggerSource.pieceName) || isNil(triggerSource.pieceVersion) || isNil(triggerSource.triggerName) || isNil(triggerSource.projectId)) {
            return null
        }
        const pieceTrigger = await triggerUtils(logger).getPieceTriggerByName({
            pieceName: triggerSource.pieceName,
            pieceVersion: triggerSource.pieceVersion,
            triggerName: triggerSource.triggerName,
            projectId: triggerSource.projectId,
        })
        if (isNil(pieceTrigger)) {
            return null
        }
        return pieceTrigger?.handshakeConfiguration ?? null
    },
}

export function isHandshakeRequest(params: IsHandshakeRequestParams): boolean {
    const { payload, handshakeConfiguration } = params

    if (isNil(handshakeConfiguration) || isNil(handshakeConfiguration.strategy)) {
        return false
    }

    const { strategy, paramName } = handshakeConfiguration

    switch (strategy) {
        case WebhookHandshakeStrategy.HEADER_PRESENT:
            return !isNil(paramName) && paramName.toLowerCase() in payload.headers

        case WebhookHandshakeStrategy.QUERY_PRESENT:
            return !isNil(paramName) && paramName in payload.queryParams

        case WebhookHandshakeStrategy.BODY_PARAM_PRESENT:
            return !isNil(paramName) &&
                typeof payload.body === 'object' &&
                payload.body !== null &&
                paramName in payload.body

        case WebhookHandshakeStrategy.HEAD_REQUEST:
            return payload.method?.toUpperCase() === 'HEAD'

        default:
            return false
    }
}

type WebhookHandshakeResponse = {
    status: number
    body?: unknown
    headers?: Record<string, string>
}

type HandleHandshakeRequestParams = {
    payload: TriggerPayload
    flowId: FlowId
    flowVersionId: FlowVersionId
    projectId: ProjectId
    handshakeConfiguration: WebhookHandshakeConfiguration | null
    logger: FastifyBaseLogger
}

type GetWebhookHandshakeConfigurationParams = {
    triggerSource: TriggerSource | null
    logger: FastifyBaseLogger
}

type IsHandshakeRequestParams = {
    payload: TriggerPayload
    handshakeConfiguration: WebhookHandshakeConfiguration | null
}