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

6.6 KB
Raw Blame
import { spawn } from 'node:child_process'
import { copyFile, cp } from 'node:fs/promises'
import { join } from 'path'
import { isNil } from '@activepieces/core-utils'
import { memoryLock } from '@activepieces/server-utils'
import { WebsocketClientEvent } from '@activepieces/shared'
import chokidar from 'chokidar'
import { FastifyInstance } from 'fastify'
import { system } from '../helper/system/system'
import { AppSystemProp } from '../helper/system/system-props'
import { filePiecesUtils } from './metadata/utils/file-pieces-utils'
import { invalidateDevPieceCache } from './metadata/utils/piece-cache-utils'

const PIECES_BUILDER_MUTEX_KEY = 'pieces-builder'

async function buildPieces(app: FastifyInstance, piecesInfo: PieceInfo[]): Promise<void> {
    if (piecesInfo.length === 0) return

    for (const piece of piecesInfo) {
        if (!/^[A-Za-z0-9-]+$/.test(piece.pieceName)) {
            throw new Error(`Piece package name contains invalid character: ${piece.pieceName}`)
        }
    }

    const pieceFilters = piecesInfo.map(p => `--filter=${p.packageName}`)
    const filterArgs = [
        '--filter=@activepieces/pieces-framework',
        '--filter=@activepieces/pieces-common',
        '--filter=@activepieces/shared',
        ...pieceFilters,
        '--force',
    ]
    app.log.info(`Building ${piecesInfo.length} piece(s): ${piecesInfo.map(p => p.pieceName).join(',')}...`)

    const lock = await memoryLock.acquire(PIECES_BUILDER_MUTEX_KEY)
    try {
        const startTime = performance.now()
        await spawnAndWait('npx', ['turbo', 'run', 'build', ...filterArgs])
        const buildTime = (performance.now() - startTime) / 1000

        app.log.info(`Build completed in ${buildTime.toFixed(2)} seconds`)

        const utils = filePiecesUtils(app.log)
        await Promise.all(piecesInfo.map(async (piece) => {
            await copyPackageJsonToDist(piece.pieceDirectory)
            await copyI18nToDist(piece.pieceDirectory)
            const distPath = await utils.findDistPiecePathByPackageName(piece.packageName)
            if (distPath) {
                utils.clearPieceModuleCache(distPath)
            }
        }))

        invalidateDevPieceCache()
        app.io.emit(WebsocketClientEvent.REFRESH_PIECE)
        app.log.info('Changes are ready! Please refresh the frontend to see the new updates.')
    }
    catch (error) {
        app.log.error({ error }, 'Failed to run build process...')
    }
    finally {
        await lock.release()
    }
}

export async function startDevPieceWatcher(app: FastifyInstance): Promise<void> {
    const devPiecesConfig = system.get(AppSystemProp.DEV_PIECES)
    if (isNil(devPiecesConfig) || devPiecesConfig.trim() === '') return

    const piecesNames = [...new Set(devPiecesConfig.split(',').map(n => n.trim()))]
    const utils = filePiecesUtils(app.log)

    const resolvedInfos = await Promise.all(piecesNames.map(async (pieceName) => {
        const pieceDirectory = await utils.findSourcePiecePathByPieceName(pieceName)
        if (isNil(pieceDirectory)) {
            app.log.warn(`Piece directory not found for: ${pieceName}`)
            return null
        }
        const packageName = await utils.getPackageNameFromFolderPath(pieceDirectory)
        return { pieceName, pieceDirectory, packageName }
    }))
    const pieceInfos: PieceInfo[] = resolvedInfos.filter((info): info is PieceInfo => info !== null)

    if (pieceInfos.length === 0) return

    const rebuilding = new Set<string>()
    const debounceTimers = new Map<string, ReturnType<typeof setTimeout>>()
    const pendingRebuild = new Set<string>()

    const watchPaths = pieceInfos.flatMap(p => [
        join(p.pieceDirectory, 'src'),
        join(p.pieceDirectory, 'package.json'),
    ])

    const triggerBuild = async (piecesToBuild: PieceInfo[]): Promise<void> => {
        piecesToBuild.forEach(p => rebuilding.add(p.pieceName))
        try {
            await buildPieces(app, piecesToBuild)
        }
        finally {
            piecesToBuild.forEach(p => rebuilding.delete(p.pieceName))
        }
        const pending = piecesToBuild.filter(p => pendingRebuild.has(p.pieceName))
        pending.forEach(p => pendingRebuild.delete(p.pieceName))
        if (pending.length > 0) {
            startBuild(pending)
        }
    }

    const startBuild = (piecesToBuild: PieceInfo[]): void => {
        triggerBuild(piecesToBuild).catch((error) => app.log.error({ error }, 'Failed to build dev pieces'))
    }

    const watcher = chokidar.watch(watchPaths, { ignoreInitial: true })

    watcher.on('all', (_event, filePath) => {
        const pieceInfo = pieceInfos.find(p => filePath.startsWith(p.pieceDirectory))
        if (!pieceInfo) return

        clearTimeout(debounceTimers.get(pieceInfo.pieceName))
        debounceTimers.set(pieceInfo.pieceName, setTimeout(() => {
            debounceTimers.delete(pieceInfo.pieceName)
            if (rebuilding.has(pieceInfo.pieceName)) {
                pendingRebuild.add(pieceInfo.pieceName)
                return
            }
            startBuild([pieceInfo])
        }, 300))
    })

    watcher.on('error', (error) => {
        app.log.error({ error }, 'File watcher error')
    })

    for (const pieceInfo of pieceInfos) {
        app.log.info(`Watching for changes: ${pieceInfo.pieceName}`)
    }

    const cleanup = async () => {
        await watcher.close()
        for (const timer of debounceTimers.values()) {
            clearTimeout(timer)
        }
    }
    process.once('SIGINT', () => void cleanup())
    process.once('SIGTERM', () => void cleanup())
}

function spawnAndWait(cmd: string, args: string[]): Promise<void> {
    return new Promise((resolve, reject) => {
        const child = spawn(cmd, args, {
            cwd: process.cwd(),
            stdio: 'inherit',
            shell: false,
        })
        child.on('close', (code) => {
            if (code === 0) {
                resolve()
            }
            else {
                reject(new Error(`Command "${cmd}" exited with code ${code}`))
            }
        })
        child.on('error', reject)
    })
}

async function copyPackageJsonToDist(sourceDir: string): Promise<void> {
    const distDir = join(sourceDir, 'dist')
    await copyFile(join(sourceDir, 'package.json'), join(distDir, 'package.json'))
}

async function copyI18nToDist(sourceDir: string): Promise<void> {
    const i18nSrc = join(sourceDir, 'src', 'i18n')
    const distDir = join(sourceDir, 'dist')
    try {
        await cp(i18nSrc, join(distDir, 'src', 'i18n'), { recursive: true })
    }
    catch (error) {
        if ((error as NodeJS.ErrnoException).code !== 'ENOENT') throw error
    }
}

type PieceInfo = {
    packageName: string
    pieceName: string
    pieceDirectory: string
}