@seeka-labs/cli-apps 3.7.0 → 3.8.2

package/dist/ai-context/internal/examples/v1/activecampaign/src/functions/seekaAppWebhook.ts

@@ -0,0 +1,284 @@
+import { app, HttpRequest, HttpResponseInit, InvocationContext } from '@azure/functions';
+import {
+    ActivityPayload,
+    SeekaActivityAcceptedWebhookPayload, SeekaAppInstalledWebhookPayload,
+    SeekaAppInstallSettingsUpdatedWebhookPayload, SeekaAppUninstalledWebhookPayload,
+    SeekaWebhookCallType, SeekaWebhookPayload,
+    throwOnInvalidWebhookSignature
+} from '@seeka-labs/sdk-apps-server';
+
+import { webhookLogger } from '../lib/logging';
+import { startServices } from '../lib/services';
+import {
+    createOrUpdateInstallation, deleteInstallation, SeekaAppInstallState, tryGetInstallation
+} from '../lib/state/seeka/installations';
+
+import type { Logger } from 'winston';
+import { createOrUpdateActiveCampaignContact, findActiveCampaignContactByEmail, seekaIdentityToActiveCampaignContact } from '../lib/active-campaign/contacts';
+import { first } from 'lodash';
+import { getMatchingPipelineMapper, maintainPipelinesForInstallation } from '../lib/active-campaign/pipelines';
+import { ActiveCampaignPipelineDealStatus, createPipelineDealInActiveCampaign, getPipelineDealForContactInActiveCampaign, updatePipelineDealInActiveCampaign } from '../lib/active-campaign/pipelines/deals';
+import * as winston from 'winston';
+
+app.http('seekaAppWebhook', {
+    methods: ['POST'],
+    authLevel: 'anonymous',
+    route: 'webhook/seeka/app',
+    handler: seekaAppWebhook
+});
+
+export async function seekaAppWebhook(req: HttpRequest, context: InvocationContext): Promise<HttpResponseInit> {
+    const bodyStr = (await req.text()) as string;
+    const body = JSON.parse(bodyStr) as SeekaWebhookPayload;
+
+    const logger = webhookLogger(body, context);
+    logger.profile('http.seeka.webhook.app')
+    logger.verbose('Received webhook from Seeka', { body });
+
+    // Handle probe
+    if (body.type === SeekaWebhookCallType.Probe) {
+        return {
+            status: 204
+        }
+    }
+
+    // Validate webhook
+    try {
+        throwOnInvalidWebhookSignature(process.env.SEEKA_APP_SECRET as string, req.headers, bodyStr);
+        logger.debug('Webhook signature validated', { body });
+    }
+    catch {
+        logger.warn('Webhook signature invalid', { body });
+        return {
+            status: 401,
+            jsonBody: { error: "Webhook call invalid" }
+        }
+    }
+
+    if (body.isTest) {
+        // This is a test webhook call
+        return {
+            status: 204
+        }
+    }
+
+    await startServices(logger);
+
+    // Check if the webhook is for an app we have installed
+    let installation: SeekaAppInstallState | null = null;
+    if (body.type != SeekaWebhookCallType.AppInstalled) {
+        installation = await tryGetInstallation((body as SeekaAppInstalledWebhookPayload).context?.applicationInstallId as string, false, logger);
+        if (installation == null) {
+            logger.warn('Webhook call cannot be processed as the installation ID is not known by this app', { body });
+
+            return {
+                status: 422,
+                jsonBody: { error: "App not installed" }
+            }
+        }
+    }
+
+    // Do something
+    try {
+        switch (body.type) {
+            case SeekaWebhookCallType.AppInstalled:
+                {
+                    await onInstallation(body as SeekaAppInstalledWebhookPayload, logger);
+                    break;
+                }
+            case SeekaWebhookCallType.AppInstallSettingsUpdated:
+                {
+                    await onInstallationSettingsUpdate(body as SeekaAppInstallSettingsUpdatedWebhookPayload, logger);
+                    break;
+                }
+            case SeekaWebhookCallType.AppUninstalled:
+                {
+                    if (!body.isTest) {
+                        const payload = body as SeekaAppUninstalledWebhookPayload;
+                        await deleteInstallation(payload.context?.applicationInstallId as string, logger)
+                    }
+                    break;
+                }
+            case SeekaWebhookCallType.ActivityAccepted:
+                {
+                    const payload = body as SeekaActivityAcceptedWebhookPayload;
+                    await handleSeekaActivity(installation, payload, logger);
+
+                    break;
+                }
+            case SeekaWebhookCallType.IdentityChanged:
+                {
+                    // no-op
+                    // const payload = body as SeekaIdentityChangedWebhookPayload;
+                    break;
+                }
+        }
+    }
+    catch (err) {
+        logger.error('Failed to handle webhook', { exception: winston.exceptions.getAllInfo(err) });
+        return {
+            status: 500,
+            jsonBody: { error: "Request failed" }
+        }
+    }
+    finally {
+        logger.profile('http.seeka.webhook.app')
+        logger.verbose('Seeka webhook handled');
+    }
+
+    return {
+        status: 204
+    }
+}
+
+const onInstallation = async (payload: SeekaAppInstalledWebhookPayload, logger: Logger) => {
+    if (payload.isTest) return;
+
+    const installation = await createOrUpdateInstallation({
+        ...payload.context,
+        applicationInstallId: payload.context?.applicationInstallId as string,
+        organisationBrandId: payload.context?.organisationBrandId as string,
+        organisationId: payload.context?.organisationId as string,
+        installationState: {
+            grantedPermissions: payload.content?.grantedPermissions || []
+        },
+        installedAt: new Date().toISOString(),
+        installationSettings: payload.content?.installationSettings || {}
+    }, logger)
+
+
+    await maintainPipelinesForInstallation(installation, logger);
+}
+
+const onInstallationSettingsUpdate = async (payload: SeekaAppInstallSettingsUpdatedWebhookPayload, logger: Logger) => {
+    if (payload.isTest) return;
+
+    let existingInstallation = await tryGetInstallation(payload.context?.applicationInstallId as string, true, logger) as SeekaAppInstallState;
+    existingInstallation = await createOrUpdateInstallation({
+        ...existingInstallation,
+        installationState: {
+            ...existingInstallation.installationState,
+            grantedPermissions: payload.content?.grantedPermissions || []
+        },
+        installationSettings: payload.content?.installationSettings || {},
+    }, logger)
+
+    await maintainPipelinesForInstallation(existingInstallation, logger);
+}
+
+const handleSeekaActivity = async (installation: SeekaAppInstallState, activity: SeekaActivityAcceptedWebhookPayload, logger: Logger) => {
+    // Make sure there is an activity and identifiers
+    if (!activity.content || !activity.content.activity || !activity.content.identifiers) return;
+
+    const seekaIdentity = activity.content.identifiers;
+
+    if (seekaIdentity.email && seekaIdentity.email.length > 0) {
+        // Check if the activity should trigger the maintenance of a deal
+        const map = getMatchingPipelineMapper(installation, activity.content.activity, logger);
+        if (map === null) {
+            logger.verbose('No matching pipeline map found for activity', { activity: activity.content.activity.activityNameCustom || activity.content.activity.activityName });
+            return;
+        }
+        if (!map.stage) {
+            logger.verbose('No stage found for activity', { activity: activity.content.activity.activityNameCustom || activity.content.activity.activityName });
+            return;
+        }
+
+        // Find contact in ActiveCampaign    
+        let activeCampaignContact = await findActiveCampaignContactByEmail(installation, first(seekaIdentity.email), logger);
+
+        if (!activeCampaignContact) {
+            // Create contact
+            logger.verbose('Existing contact not found in ActiveCampaign, creating', { email: first(seekaIdentity.email) });
+            const newContact = seekaIdentityToActiveCampaignContact(seekaIdentity);
+            activeCampaignContact = await createOrUpdateActiveCampaignContact(installation, newContact, logger);
+        }
+        else {
+            logger.verbose('Existing contact found in ActiveCampaign', { email: first(seekaIdentity.email) });
+        }
+
+        // Check if the pipeline exists in ActiveCampaign
+        const pipelineInfo = installation.installationState.dealMapperNamesToActiveCampaignPipelineInfo[map.mapper.pipelineName];
+        if (pipelineInfo) {
+            // Check if deal exists in active campaign
+            let pipelineDeal = await getPipelineDealForContactInActiveCampaign(installation, pipelineInfo.pipelineId, activeCampaignContact.id, logger);
+
+            // Check which stage the deal should be in 
+            const activeCampaignTargetStageId = map.activeCampaignPipeline.stageNamesToStageIds[map.stage.name];
+            if (!activeCampaignTargetStageId) {
+                logger.error('Stage not found in installation state', { stageName: map.stage.name, installation: installation.applicationInstallId });
+                return;
+            }
+
+            const targetValue = getValue(activity.content.activity);
+            const targetValueInCents = parseInt((targetValue * 100).toFixed(0));
+
+            const targetCurrency = activity.content.activity.properties?.currencyCode ||
+                activity.content.activity.lead?.currencyCode ||
+                activity.content.activity.commerce?.currencyCode ||
+                map.mapper.dealCurrencyCode?.toLowerCase();
+            const targetTitle = `${first(seekaIdentity.firstName)} ${first(seekaIdentity.lastName)}`;
+            const targetStatus = ActiveCampaignPipelineDealStatus[map.stage.status];
+            if (targetStatus === undefined) {
+                logger.error('Status not found in installation state', { status: map.stage.status, installation: installation.applicationInstallId });
+                return;
+            }
+
+            if (!pipelineDeal) {
+                // Create the deal
+                logger.verbose('Existing deal not found in ActiveCampaign, creating', { contact: activeCampaignContact.id, title: targetTitle });
+                pipelineDeal = await createPipelineDealInActiveCampaign(installation, {
+                    contact: activeCampaignContact.id,
+                    title: targetTitle,
+                    currency: targetCurrency,
+                    group: pipelineInfo.pipelineId,
+                    value: targetValueInCents,
+                    status: targetStatus,
+                    stage: activeCampaignTargetStageId
+                }, logger);
+            }
+            else {
+                // Update deal if needed
+                logger.verbose('Existing deal found in ActiveCampaign', { deal: pipelineDeal });
+
+                if (pipelineDeal.status != targetStatus || pipelineDeal.stage !== activeCampaignTargetStageId || pipelineDeal.value !== targetValueInCents || pipelineDeal.currency !== targetCurrency || pipelineDeal.title !== targetTitle) {
+                    logger.verbose('Existing deal found in ActiveCampaign and requires updating, updating', { deal: pipelineDeal });
+                    pipelineDeal.stage = activeCampaignTargetStageId;
+                    pipelineDeal.value = targetValueInCents;
+                    pipelineDeal.currency = targetCurrency;
+                    pipelineDeal.title = targetTitle;
+                    pipelineDeal.status = targetStatus;
+                    pipelineDeal = await updatePipelineDealInActiveCampaign(installation, pipelineDeal.id, pipelineDeal, logger);
+                }
+            }
+        }
+        else {
+            logger.error('Pipeline not found in installation state', { pipelineName: map.mapper.pipelineName, installation: installation.applicationInstallId });
+        }
+    }
+}
+
+const getValue = (activity: ActivityPayload): number => {
+    if (activity.lead) {
+        const val = (activity.lead.predictedValue || activity.lead.predictedLtv);
+        if (val) {
+            return val;
+        }
+    }
+
+    if (activity.properties && activity.properties.value) {
+        const float = parseFloat(activity.properties.value?.toString());
+        if (!isNaN(float)) {
+            return float;
+        }
+    }
+
+    if (activity.commerce) {
+        const val = activity.commerce.totalPrice || activity.commerce.totalLineItemsPrice;
+        if (val) {
+            return val;
+        }
+    }
+
+    return 1;
+}

package/dist/ai-context/internal/examples/v1/activecampaign/src/lib/active-campaign/api/index.ts

@@ -0,0 +1,41 @@
+import axios, { Method } from "axios";
+import { SeekaAppInstallState } from "../../state/seeka/installations";
+import { Logger } from "winston";
+
+export async function makeActiveCampaignApiRequest<TResponse>(path: string, method: Method, body: unknown | undefined, installation: SeekaAppInstallState, logger: Logger): Promise<TResponse> {
+    // Remove leading / from path
+    if (path.startsWith('/')) {
+        path = path.substring(1);
+    }
+    // Remove leading / from installation URL
+    let baseUrl = installation.installationSettings.activeCampaignApiUrl;
+    if (baseUrl.startsWith('/')) {
+        baseUrl = baseUrl.substring(1);
+    }
+    const fullUrl = `${baseUrl}/${path}`;
+
+    try {
+        const response = await axios.request({
+            url: fullUrl,
+            method,
+            data: body ? JSON.stringify(body) : undefined,
+            headers: {
+                'Accept': 'application/json',
+                'Content-Type': 'application/json',
+                'Api-Token': installation.installationSettings.activeCampaignApiKey,
+            }
+        })
+
+        if (response.status < 200 || response.status >= 300) {
+            logger.error('Error making ActiveCampaign API request', { path, method, body, installation: installation.applicationInstallId, status: response.status, statusText: response.statusText, data: response.data, fullUrl });
+            throw new Error(`Error making ActiveCampaign API request - status ${response.status}: ${response.statusText}`);
+        }
+
+        logger.debug('Made ActiveCampaign API request', { path, method, installation: installation.applicationInstallId, fullUrl });
+        return response.data;
+    }
+    catch (err) {
+        logger.error('Error making ActiveCampaign API request', { path, method, body, installation: installation.applicationInstallId, error: err, fullUrl });
+        throw new Error('Error making ActiveCampaign API request')
+    }
+}

package/dist/ai-context/internal/examples/v1/activecampaign/src/lib/active-campaign/contacts/index.ts

@@ -0,0 +1,56 @@
+import { PersonIdentifiers } from "@seeka-labs/sdk-apps-server";
+import { SeekaAppInstallState } from "../../state/seeka/installations";
+import { Logger } from "winston";
+import { first, last } from 'lodash'
+import { makeActiveCampaignApiRequest } from "../api";
+
+export const createOrUpdateActiveCampaignContact = async (installation: SeekaAppInstallState, contact: ActiveCampaignContact, logger: Logger): Promise<ActiveCampaignContactWithId> => {
+    // https://developers.activecampaign.com/reference/sync-a-contacts-data
+    const response = await makeActiveCampaignApiRequest<ActiveCampaignContactResponse>(`/api/3/contact/sync`, 'POST', {
+        contact: contact
+    }, installation, logger)
+
+    return response.contact;
+}
+
+export const findActiveCampaignContactByEmail = async (installation: SeekaAppInstallState, email: string, logger: Logger): Promise<ActiveCampaignContactWithId | null> => {
+    const response = await makeActiveCampaignApiRequest<ActiveCampaignContactListResponse>(`/api/3/contacts?email=${encodeURIComponent(email)}`, 'GET', undefined, installation, logger)
+
+    if (response.contacts.length > 0) {
+        return response.contacts[0];
+    }
+    else if (response.contacts.length === 0) {
+        return null
+    }
+    else {
+        throw new Error('ActiveCampaign API returned more than 1 result for the email ' + email)
+    }
+}
+
+export const seekaIdentityToActiveCampaignContact = (seekaIdentity: PersonIdentifiers): ActiveCampaignContact => {
+    return {
+        email: seekaIdentity.email && seekaIdentity.email.length > 0 ? first(seekaIdentity.email) : undefined,
+        firstName: seekaIdentity.firstName && seekaIdentity.firstName.length > 0 ? first(seekaIdentity.firstName) : undefined,
+        lastName: seekaIdentity.lastName && seekaIdentity.lastName.length > 0 ? first(seekaIdentity.lastName) : undefined,
+        phone: seekaIdentity.phone && seekaIdentity.phone.length > 0 ? first(seekaIdentity.phone) : undefined
+    }
+}
+
+export interface ActiveCampaignContactResponse {
+    contact: ActiveCampaignContactWithId
+}
+
+export interface ActiveCampaignContactListResponse {
+    contacts: ActiveCampaignContactWithId[]
+}
+
+export interface ActiveCampaignContactWithId extends ActiveCampaignContact {
+    id: string
+}
+
+export interface ActiveCampaignContact {
+    email?: string
+    firstName?: string
+    lastName?: string
+    phone?: string
+}

package/dist/ai-context/internal/examples/v1/activecampaign/src/lib/active-campaign/custom-fields/index.ts

@@ -0,0 +1,8 @@
+import { PersonIdentifiers } from "@seeka-labs/sdk-apps-server";
+import { SeekaAppInstallState } from "../../state/seeka/installations";
+import { Logger } from "winston";
+
+export const ensureSeekaPersonIdCustomFieldExists = async (installation: SeekaAppInstallState, logger: Logger): Promise<void> => {
+
+
+}

package/dist/ai-context/internal/examples/v1/activecampaign/src/lib/active-campaign/pipelines/deals/index.ts

@@ -0,0 +1,96 @@
+import { Logger } from "winston";
+import { ActiveCampaignListPipelinesResponse } from "..";
+import { SeekaAppInstallState } from "../../../state/seeka/installations";
+import { makeActiveCampaignApiRequest } from "../../api";
+
+const maxPageSize = 100;
+
+const listPipelineDealsInActiveCampaign = async (installation: SeekaAppInstallState, pipelineId: string, skip: number, logger: Logger): Promise<ActiveCampaignListPipelineDealsResponse> => {
+    // https://developers.activecampaign.com/reference/list-all-deals
+    const response = await makeActiveCampaignApiRequest<ActiveCampaignListPipelineDealsResponse>(`/api/3/deals?limit=${maxPageSize}&filters[group]=${pipelineId}&skip=${skip}`, 'GET', undefined, installation, logger);
+
+    return response;
+}
+
+export const listAllPipelineDealsInActiveCampaign = async (installation: SeekaAppInstallState, pipelineId: string, logger: Logger): Promise<ActiveCampaignPipelineDealWithId[]> => {
+    const allItems: ActiveCampaignPipelineDealWithId[] = [];
+
+    let skip = 0;
+    // eslint-disable-next-line no-constant-condition
+    while (true) {
+        const response = await listPipelineDealsInActiveCampaign(installation, pipelineId, skip, logger);
+        allItems.push(...response.deals);
+        if (response.deals.length < maxPageSize) {
+            break;
+        }
+        skip += maxPageSize;
+    }
+
+    return allItems;
+}
+
+export const createPipelineDealInActiveCampaign = async (installation: SeekaAppInstallState, deal: ActiveCampaignPipelineDeal, logger: Logger): Promise<ActiveCampaignPipelineDealWithId> => {
+    // https://developers.activecampaign.com/reference/create-a-deal-new
+    const response = await makeActiveCampaignApiRequest<ActiveCampaignCreatePipelineDealResponse>(`/api/3/deals`, 'POST', {
+        deal: deal
+    }, installation, logger);
+
+    return response.deal;
+}
+
+export const updatePipelineDealInActiveCampaign = async (installation: SeekaAppInstallState, dealId: string, deal: ActiveCampaignPipelineDeal, logger: Logger): Promise<ActiveCampaignPipelineDealWithId> => {
+    // https://developers.activecampaign.com/reference/update-a-deal-new
+    const response = await makeActiveCampaignApiRequest<ActiveCampaignCreatePipelineDealResponse>(`/api/3/deals/${dealId}`, 'PUT', {
+        deal: deal
+    }, installation, logger);
+
+    return response.deal;
+}
+
+export const getPipelineDealForContactInActiveCampaign = async (installation: SeekaAppInstallState, pipelineId: string, contactId: string, logger: Logger): Promise<ActiveCampaignPipelineDealWithId | null> => {
+    let skip = 0;
+    // eslint-disable-next-line no-constant-condition
+    while (true) {
+        const response = await listPipelineDealsInActiveCampaign(installation, pipelineId, skip, logger);
+
+        const forContact = response.deals.find(e => e.contact === contactId);
+        if (forContact) {
+            return forContact;
+        }
+
+        if (response.deals.length < maxPageSize) {
+            break;
+        }
+        skip += maxPageSize;
+    }
+
+    return null;
+}
+
+export enum ActiveCampaignPipelineDealStatus {
+    open = 0,
+    won = 1,
+    lost = 2,
+}
+
+export interface ActiveCampaignPipelineDeal {
+    contact?: string;
+    stage?: string;
+    title?: string
+    currency?: string
+    group?: string
+    value: number
+    status: number
+}
+
+export interface ActiveCampaignCreatePipelineDealResponse {
+    deal: ActiveCampaignPipelineDealWithId
+}
+
+export interface ActiveCampaignListPipelineDealsResponse {
+    deals: ActiveCampaignPipelineDealWithId[]
+}
+
+export interface ActiveCampaignPipelineDealWithId extends ActiveCampaignPipelineDeal {
+    id: string
+}