@seeka-labs/cli-apps 3.7.0 → 3.8.2

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

@@ -0,0 +1,206 @@
+import { ActivityPayloadBase, TrackingActivityNames } from "@seeka-labs/sdk-apps-server";
+import { ActiveCampaignPipelineLookupInfo, DealMappingDefinitionStage, SeekaAppInstallState, createOrUpdateInstallation } from "../../state/seeka/installations";
+import { DealMappingDefinition } from "../..//state/seeka/installations";
+import { Logger } from "winston";
+import { get } from "lodash";
+import { makeActiveCampaignApiRequest } from "../api";
+
+export const getMatchingPipelineMapper = (installation: SeekaAppInstallState, activity: ActivityPayloadBase, logger: Logger): { mapper: DealMappingDefinition, activeCampaignPipeline: ActiveCampaignPipelineLookupInfo, stage: DealMappingDefinitionStage } | null => {
+    if (!installation.installationSettings.enableDealPipelines) return null;
+
+    const mappers = installation.installationSettings.dealMappers || [];
+    if (!mappers) return null;
+
+    const eventName = activity.activityName === TrackingActivityNames.Custom ? activity.activityNameCustom : activity.activityName.toString();
+    const eventNameUpper = eventName.toUpperCase();
+    for (const mapper of mappers) {
+        if (mapper.dealTriggerEventName && mapper.dealTriggerEventName.toUpperCase() === eventNameUpper) {
+            logger.verbose('Found matching pipeline mapper', { mapper, activityName: eventName });
+
+            const stageNameLookupPropValue = getPropFromActivity(activity, mapper.dealStageNameParam);
+            if (!stageNameLookupPropValue) {
+                logger.verbose('No stage name could be located from activity', { activity, mapper, dealStageNameParam: mapper.dealStageNameParam });
+                return null;
+            }
+            else {
+                logger.verbose('Found stage name lookup prop value', { stageNameLookupPropValue });
+            }
+
+            // Match to stage
+            const pipelineInfo = installation.installationState.dealMapperNamesToActiveCampaignPipelineInfo[mapper.pipelineName];
+            if (pipelineInfo) {
+                logger.debug('Found pipeline info for mapper', { mapper, pipelineInfo });
+                return {
+                    mapper: mapper,
+                    activeCampaignPipeline: pipelineInfo,
+                    stage: mapper.dealStages.find(s => s.name === stageNameLookupPropValue)
+                }
+            }
+        }
+    }
+
+    return null;
+}
+
+const getPropFromActivity = (activity: ActivityPayloadBase, propName: string): string | undefined => {
+    if (propName.startsWith('custom')) {
+        return activity.properties[propName.replace('custom.', '')] || undefined;
+    }
+
+    return get(activity, propName) || undefined;
+}
+
+const createPipelineInActiveCampaign = async (installation: SeekaAppInstallState, pipeline: ActiveCampaignPipeline, logger: Logger): Promise<ActiveCampaignPipelineWithId> => {
+    // https://developers.activecampaign.com/reference/create-a-pipeline
+    const response = await makeActiveCampaignApiRequest<ActiveCampaignCreatePipelineResponse>(`/api/3/dealGroups`, 'POST', {
+        dealGroup: pipeline
+    }, installation, logger);
+
+    return response.dealGroup;
+}
+
+const listPipelinesInActiveCampaign = async (installation: SeekaAppInstallState, logger: Logger): Promise<ActiveCampaignListPipelinesResponse> => {
+    // https://developers.activecampaign.com/reference/list-all-pipelines
+    // TODO: Support retrieving more than 100 pipelines
+    const response = await makeActiveCampaignApiRequest<ActiveCampaignListPipelinesResponse>(`/api/3/dealGroups?limit=100`, 'GET', undefined, installation, logger);
+
+    return response;
+}
+
+const updatePipelineStageInActiveCampaign = async (installation: SeekaAppInstallState, pipelineId: string, stageId: string, order: number, logger: Logger): Promise<void> => {
+    await makeActiveCampaignApiRequest<unknown>(`/api/3/dealStages/${stageId}`, 'PUT', {
+        dealStage: {
+            // "cardRegion1": "title",
+            // "cardRegion2": "next-action",
+            // "cardRegion3": "show-avatar",
+            // "cardRegion4": "contact-fullname-orgname",
+            // "cardRegion5": "value",
+            // "color": "32B0FC",
+            // "dealOrder": "next-action DESC",
+            "group": pipelineId,
+            "order": order,
+            // "width": 360
+        }
+    }, installation, logger);
+}
+
+const createPipelineStageInActiveCampaign = async (installation: SeekaAppInstallState, pipelineId: string, stageName: string, order: number, logger: Logger): Promise<ActiveCampaignPipelineStage> => {
+    const response = await makeActiveCampaignApiRequest<{ dealStage: ActiveCampaignPipelineStage }>(`/api/3/dealStages`, 'POST', {
+        dealStage: {
+            // "cardRegion1": "title",
+            // "cardRegion2": "next-action",
+            // "cardRegion3": "show-avatar",
+            // "cardRegion4": "contact-fullname-orgname",
+            // "cardRegion5": "value",
+            // "color": "32B0FC",
+            // "dealOrder": "next-action DESC",
+            "group": pipelineId,
+            "order": order,
+            "title": stageName,
+            // "width": 360
+        }
+    }, installation, logger);
+
+    return { ...response.dealStage };
+}
+
+// const tryGetPipelineFromActiveCampaign = async (installation: SeekaAppInstallState, pipelineName: string, logger: Logger) => {
+
+// }
+
+export const maintainPipelinesForInstallation = async (installation: SeekaAppInstallState, logger: Logger) => {
+    if (!installation.installationSettings.enableDealPipelines || !installation.installationSettings.dealMappers || installation.installationSettings.dealMappers.length === 0) return;
+
+    const pipelineMappings = installation.installationState.dealMapperNamesToActiveCampaignPipelineInfo;
+
+    const existingPipelines = await listPipelinesInActiveCampaign(installation, logger);
+
+    for (const mapper of installation.installationSettings.dealMappers) {
+        // Try find pipeline in ActiveCampaign
+        let activeCampaignPipeline: ActiveCampaignPipelineWithId | undefined = existingPipelines.dealGroups.find(p => p.title === mapper.pipelineName);
+
+        if (!activeCampaignPipeline) {
+            // Create pipeline in ActiveCampaign
+            activeCampaignPipeline = await createPipelineInActiveCampaign(installation, {
+                title: mapper.pipelineName,
+                autoassign: ActiveCampaignPipelineAutoassignType.RoundRobin,
+                currency: mapper.dealCurrencyCode?.toLowerCase()
+            }, logger);
+        }
+
+        pipelineMappings[mapper.pipelineName] = {
+            pipelineId: activeCampaignPipeline.id,
+            stageNamesToStageIds: {}
+        };
+
+        // Maintain stages
+        const pipelineInfo = pipelineMappings[mapper.pipelineName];
+        if (!pipelineInfo) {
+            logger.error('Pipeline info not found for mapper', { mapper });
+            continue;
+        }
+        if (!mapper.dealStages || mapper.dealStages.length === 0) {
+            logger.error('No deal stages found on mapper', { mapper });
+            continue;
+        }
+
+        mapper.dealStages.forEach(async (stage, index) => {
+            const stageName = stage.name;
+            const activeCampaignIndex = index + 1;
+            // Try find stage in ActiveCampaign
+            let pipelineStage: ActiveCampaignPipelineStage | undefined = existingPipelines.dealStages.find(s => s.title === stageName && s.group === pipelineInfo.pipelineId);
+
+            if (!pipelineStage) {
+                // Create stage in ActiveCampaign
+                logger.verbose('Stage doesnt exist in mapping, creating in ActiveCampaign', { stageName, pipelineName: mapper.pipelineName });
+                pipelineStage = await createPipelineStageInActiveCampaign(installation, pipelineInfo.pipelineId, stageName, activeCampaignIndex, logger);
+            }
+            else if (pipelineStage.order !== activeCampaignIndex.toString()) {
+                // Update state order
+                logger.verbose('Stage already exists in mapping and order is different, updating it in ActiveCampaign', { stageName, pipelineName: mapper.pipelineName });
+                await updatePipelineStageInActiveCampaign(installation, pipelineInfo.pipelineId, pipelineInfo.stageNamesToStageIds[stageName], activeCampaignIndex, logger)
+            }
+
+            pipelineInfo.stageNamesToStageIds[stageName] = pipelineStage.id;
+        });
+    }
+
+    installation.installationState.dealMapperNamesToActiveCampaignPipelineInfo = pipelineMappings;
+
+    await createOrUpdateInstallation(installation, logger);
+}
+
+export interface ActiveCampaignPipeline {
+    allgroups?: number;
+    allusers?: number;
+    autoassign?: ActiveCampaignPipelineAutoassignType;
+    currency?: string;
+    title: string
+}
+
+export enum ActiveCampaignPipelineAutoassignType {
+    Disabled = 0,
+    RoundRobin = 1,
+    DealValue = 2,
+}
+
+export interface ActiveCampaignCreatePipelineResponse {
+    dealGroup: ActiveCampaignPipelineWithId
+}
+
+export interface ActiveCampaignListPipelinesResponse {
+    dealGroups: ActiveCampaignPipelineWithId[]
+    dealStages: ActiveCampaignPipelineStage[]
+}
+
+export interface ActiveCampaignPipelineWithId extends ActiveCampaignPipeline {
+    id: string
+    stages: string[]
+}
+
+export interface ActiveCampaignPipelineStage {
+    id: string
+    title: string
+    group: string
+    order: string
+}

package/dist/ai-context/internal/examples/v1/activecampaign/src/lib/logging/index.ts

@@ -0,0 +1,77 @@
+import * as winston from 'winston';
+
+import { InvocationContext } from '@azure/functions';
+import { SeqTransport } from '@datalust/winston-seq';
+
+import * as packageJson from '../../../package.json';
+
+import type {
+    SeekaWebhookPayload, SeekaWebhookPayloadOfSeekaAppWebhookContext
+} from '@seeka-labs/sdk-apps-server';
+
+const loggerTransports: winston.transport[] = [
+    new winston.transports.Console({
+        level: process.env.LOGGING_LEVEL,
+        format: winston.format.combine(
+            winston.format.errors({ stack: true }),
+            winston.format.cli(),
+            winston.format.splat(),
+        ),
+        handleExceptions: true,
+        handleRejections: true,
+    }),
+]
+if (process.env.LOGGING_SEQ_SERVERURL) {
+    loggerTransports.push(
+        new SeqTransport({
+            level: process.env.LOGGING_LEVEL,
+            serverUrl: process.env.LOGGING_SEQ_SERVERURL,
+            apiKey: process.env.LOGGING_SEQ_APIKEY,
+            onError: ((e) => { console.error('Failed to configure Seq logging transport', e) }),
+            format: winston.format.combine(
+                winston.format.errors({ stack: true }),
+                winston.format.json(),
+            ),
+            handleExceptions: true,
+            handleRejections: true,
+        }) as never
+    )
+}
+
+export const logger = winston.createLogger({
+    level: process.env.LOGGING_LEVEL,
+    defaultMeta: {
+        seekaAppId: process.env.SEEKA_APP_ID,
+        Hosting_Provider: 'azure',
+        Release_Version: `v${packageJson.version}`,
+        Hosting_Region: process.env.REGION_NAME,
+        Service_Instance_Id: process.env.WEBSITE_ROLE_INSTANCE_ID,
+        AzureFunctions_FunctionName: process.env.WEBSITE_SITE_NAME,
+        Service: `app/${packageJson.name}`,
+    },
+    transports: loggerTransports,
+    exitOnError: false,
+});
+
+export const childLogger = (meta: object) => logger.child(meta);
+
+export const webhookLogger = (payload: SeekaWebhookPayload, functionContext: InvocationContext) => {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const meta: any = {
+        seekaWebhookType: payload.type,
+        seekaWebhookIsTest: payload.isTest,
+        RequestId: payload.requestId,
+        AzureFunctions_InvocationId: functionContext.invocationId,
+        CausationId: payload.causationId,
+        CorrelationId: payload.causationId,
+    }
+
+    const context = (payload as SeekaWebhookPayloadOfSeekaAppWebhookContext).context;
+    if (context) {
+        meta.seekaAppInstallId = context.applicationInstallId;
+        meta.seekaAppInstallOrganisationBrandId = context.organisationBrandId;
+        meta.seekaAppInstallOrganisationId = context.organisationId;
+    }
+
+    return childLogger(meta)
+}

package/dist/ai-context/internal/examples/v1/activecampaign/src/lib/services/index.ts

@@ -0,0 +1,41 @@
+import { connect, disconnect, isConnected } from "../state/redis";
+import { Logger } from "winston";
+import * as winston from "winston";
+
+export const startServices = async (logger: Logger) => {
+    logger.debug(`Trying to connect to Redis - ${process.env.REDIS_CONNECTION_HOST}`)
+    try {
+        if (isConnected()) {
+            logger.verbose(`Redis already connected - ${process.env.REDIS_CONNECTION_HOST}`)
+        }
+        else {
+            logger.profile('service.redis.connect')
+            await connect();
+            logger.profile('service.redis.connect')
+            logger.info(`Redis connected - ${process.env.REDIS_CONNECTION_HOST}`)
+        }
+    }
+    catch (err) {
+        logger.error(`Failed to connect to Redis - ${process.env.REDIS_CONNECTION_HOST}`, { exception: winston.exceptions.getAllInfo(err) })
+        throw err;
+    }
+}
+
+export const stopServices = async (logger: Logger) => {
+    logger.debug(`Trying to disconnect from Redis - ${process.env.REDIS_CONNECTION_HOST}`)
+    try {
+        if (isConnected() === false) {
+            logger.verbose(`Redis already disconnected - ${process.env.REDIS_CONNECTION_HOST}`)
+        }
+        else {
+            logger.profile('service.redis.disconnect')
+            await disconnect();
+            logger.profile('service.redis.disconnect')
+            logger.info(`Redis disconnected - ${process.env.REDIS_CONNECTION_HOST}`)
+        }
+    }
+    catch (err) {
+        logger.error(`Failed to disconnect from Redis - ${process.env.REDIS_CONNECTION_HOST}`, { exception: winston.exceptions.getAllInfo(err) })
+        throw err;
+    }
+}

package/dist/ai-context/internal/examples/v1/activecampaign/src/lib/state/redis/index.ts

@@ -0,0 +1,64 @@
+import { createClient } from 'redis';
+
+import { logger } from '../../logging';
+
+const redisProtocol = process.env.REDIS_CONNECTION_TLS === 'true' ? 'rediss://' : 'redis://';
+const redisConn = `${redisProtocol}${process.env.REDIS_CONNECTION_USER}:${process.env.REDIS_CONNECTION_PASSWORD}@${process.env.REDIS_CONNECTION_HOST}:${process.env.REDIS_CONNECTION_PORT}`;
+
+const redisClient = createClient({
+    url: redisConn
+})
+    .on('error', err => logger.error('Redis Client ', { error: err }));
+
+export const connect = async () => {
+    await redisClient.connect();
+}
+
+export const isConnected = () => {
+    return redisClient.isOpen;
+}
+
+export const disconnect = async () => {
+    await redisClient.disconnect();
+}
+
+const getKeyPrefix = (stateType: string) => `seeka:app:${process.env.SEEKA_APP_ID}:${stateType}`
+const getKey = (stateType: string, key: string) => `${getKeyPrefix(stateType)}:${key}`
+
+export async function getOrCreate<TState>(stateType: string, key: string, toCreate: TState): Promise<TState> {
+    const fullKey = getKey(stateType, key);
+    const existingStr = await redisClient.get(fullKey);
+    if (existingStr) return JSON.parse(existingStr);
+
+    await redisClient.set(fullKey, JSON.stringify(toCreate));
+
+    return toCreate;
+}
+
+export async function tryGet<TState>(stateType: string, key: string): Promise<TState | null> {
+    const fullKey = getKey(stateType, key);
+    const existingStr = await redisClient.get(fullKey);
+    if (existingStr) return JSON.parse(existingStr);
+
+    return null;
+}
+
+export async function getList<TState>(stateType: string): Promise<TState[]> {
+    const prefix = getKeyPrefix(stateType);
+    const allKeys = await redisClient.keys(`${prefix}:*`);
+    const listStr = await redisClient.mGet(allKeys);
+
+    if (listStr) return listStr.filter(e => Boolean(e)).map(e => JSON.parse(e as string));
+
+    return [];
+}
+
+export async function set<TState>(stateType: string, key: string, toCreate: TState): Promise<void> {
+    const fullKey = getKey(stateType, key);
+    await redisClient.set(fullKey, JSON.stringify(toCreate));
+}
+
+export async function remove(stateType: string, key: string): Promise<void> {
+    const fullKey = getKey(stateType, key);
+    await redisClient.del(fullKey);
+}

package/dist/ai-context/internal/examples/v1/activecampaign/src/lib/state/seeka/installations.ts

@@ -0,0 +1,96 @@
+import type { Logger } from 'winston';
+
+import { getList, remove, set, tryGet } from '../redis';
+import { ActiveCampaignPipelineDealStatus } from '../../active-campaign/pipelines/deals';
+
+export interface SeekaAppInstallState {
+    /** ID of the organisation that installed the app */
+    organisationId: string;
+    /** ID of the brand that installed the app */
+    organisationBrandId: string;
+    /** ID of the installation of the app */
+    applicationInstallId: string;
+    // Installation settings provided by the user installing the app
+    installationSettings: ActiveCampaignInstallSettings;
+    // State relating to the app and installation of the app
+    installationState: ActiveCampaignInstallState;
+
+    // When the app was installed
+    installedAt: string; // new Date().toISOString()
+}
+
+export interface ActiveCampaignInstallState {
+    dealMapperNamesToActiveCampaignPipelineInfo?: { [key: string]: ActiveCampaignPipelineLookupInfo }
+    grantedPermissions?: string[]
+}
+
+export interface ActiveCampaignPipelineLookupInfo {
+    pipelineId: string
+    stageNamesToStageIds: { [key: string]: string }
+}
+
+export interface DealMappingDefinition {
+    pipelineName?: string
+    dealTriggerEventName?: string
+    dealCurrencyCode?: string
+    dealIdParam?: string
+    dealStageNameParam?: string
+    dealStages?: DealMappingDefinitionStage[]
+}
+
+export interface DealMappingDefinitionStage {
+    name: string
+    status: DealMappingDefinitionStageStatus
+}
+
+export type DealMappingDefinitionStageStatus = 'open' | 'won' | 'lost'
+
+export interface ActiveCampaignInstallSettings {
+    activeCampaignApiUrl?: string
+    activeCampaignApiKey?: string
+    enableDealPipelines?: boolean
+    dealMappers?: DealMappingDefinition[]
+}
+
+const stateType = 'install'
+
+export const tryGetInstallation = async (applicationInstallId: string, throwWhenNotFound: boolean, logger: Logger): Promise<SeekaAppInstallState | null> => {
+    const installation = await tryGet<SeekaAppInstallState>(stateType, applicationInstallId);
+    if (installation == null && throwWhenNotFound) {
+        throw new Error(`Seeka installation ${applicationInstallId} not found`);
+    }
+
+    // TODO: Decrypt the ActiveCampaign API key at rest
+
+    return installation;
+}
+
+export const listInstallations = async (logger: Logger): Promise<SeekaAppInstallState[]> => {
+    const installations = await getList<SeekaAppInstallState>(stateType);
+
+    return installations;
+}
+
+
+export const createOrUpdateInstallation = async (state: SeekaAppInstallState, logger: Logger): Promise<SeekaAppInstallState> => {
+    if (!state.installationState) state.installationState = {};
+    if (!state.installedAt) state.installedAt = new Date().toISOString();
+    if (!state.installationSettings) state.installationSettings = {};
+    if (!state.installationState.dealMapperNamesToActiveCampaignPipelineInfo) state.installationState.dealMapperNamesToActiveCampaignPipelineInfo = {};
+
+    // TODO: Encrypt the ActiveCampaign API key at rest
+
+    const creating = (await tryGetInstallation(state.applicationInstallId, false, logger)) === null;
+
+    await set(stateType, state.applicationInstallId, state);
+
+    logger.info(creating ? 'Created installation state' : 'Updated installation state', { applicationInstallId: state.applicationInstallId, organisationId: state.organisationId, organisationBrandId: state.organisationBrandId });
+
+    return state;
+}
+
+export const deleteInstallation = async (applicationInstallId: string, logger: Logger): Promise<void> => {
+    await remove(stateType, applicationInstallId);
+
+    logger.info('Deleted installation state', { applicationInstallId });
+}

package/dist/ai-context/internal/examples/v1/activecampaign/tsconfig.json

@@ -0,0 +1,22 @@
+{
+  "compilerOptions": {
+    "allowJs": true,
+    "skipLibCheck": true,
+    "strict": false,
+    "esModuleInterop": false,
+    "outDir": "dist",
+    "rootDir": ".",
+    "sourceMap": true,
+    "module": "CommonJS",
+    "target": "ES6",
+    "resolveJsonModule": true,
+    "isolatedModules": false,
+  },
+  "include": [
+    "src/**/*.ts"
+  ],
+  "exclude": [
+    "node_modules",
+    "dist"
+  ]
+}

package/dist/ai-context/internal/examples/v1/complianz/.eslintrc.cjs

@@ -0,0 +1,19 @@
+/* eslint-env node */
+module.exports = {
+    extends: ['eslint:recommended', 'plugin:@typescript-eslint/recommended'],
+    parser: '@typescript-eslint/parser',
+    plugins: ['@typescript-eslint'],
+    root: true,
+    rules: {
+        "@typescript-eslint/no-unused-vars": "warn",
+        "@typescript-eslint/no-explicit-any": "off"
+    },
+    overrides: [
+        {
+            files: ["**/*/*.test.ts"],
+            env: {
+                jest: true
+            }
+        }
+    ]
+};

package/dist/ai-context/internal/examples/v1/complianz/README.md

@@ -0,0 +1,105 @@
+# Seeka app - Azure functions
+
+## Development
+
+- See [Configure your environment](https://learn.microsoft.com/en-us/azure/azure-functions/create-first-function-vs-code-typescript?pivots=nodejs-model-v4#configure-your-environment) for dependencies
+- For emulating Azure storage queues, blobs and tables: `docker run --name azurite -p 10000:10000 -p 10001:10001 -p 10002:10002 --detach mcr.microsoft.com/azure-storage/azurite`
+- Set `AzureWebJobsStorage` setting in local.settings.json to `UseDevelopmentStorage=true`
+    - If not using WSL: 
+    `UseDevelopmentStorage=true`
+    - If using WSL, the following may be required to allow your app to reach Azure storage emulator: 
+
+        Replace `MY-MACHINE-NAME` with your hostname. Below connection string allows running Azurite on your host machine and lets WSL connect to it
+        `DefaultEndpointsProtocol=http;AccountName=devstoreaccount1;AccountKey=Eby8vdM02xNOcqFlqUwJPLlmEtlCDXJ1OUzFT50uSRZ6IFsuFq2UVErCz4I6tq/K1SZFPTOtr/KBHBeksoGMGw==;BlobEndpoint=http://MY-MACHINE-NAME.local:10000/devstoreaccount1;QueueEndpoint=http://MY-MACHINE-NAME.local:10001/devstoreaccount1;TableEndpoint=http://MY-MACHINE-NAME.local:10002/devstoreaccount1;`
+- Install Azure Storage explorer and create your queues (see `./src/lib/jobs/index.ts` for `queueNames`). Azure Storage explorer can be used to view your queue items.
+- `yarn install`
+- `yarn dev`
+
+### Debugging
+Supports VSCode debugging via the debugger and utilisation of breakpoints. 
+This is only tested on Linux but may work on Windows. 
+If using Windows then use WSL with an Ubuntu distro for support of attaching the VS code debugger
+
+### Live urls
+You can expose your app locally to the internet via Ngrok to test your app before deploying.
+
+#### Setup
+1. Sign up for a Ngrok account
+2. Get your auth token
+3. `yarn ngrok config add-authtoken [auth token here]` replacing `[auth token]` with the auth token retrieved from your Ngrok dashboard
+
+#### Running
+1. `yarn start` OR start debugging in VSCode
+2. In separate terminal window run `yarn tunnel` and observe the log entry that starts with `Live url exposed`.
+3. Input the URL into your Seeka app configuration as the "Webook URL" via the Seeka UI.
+
+## Included sample functions
+### Seeka app webhook 
+`src/functions/seekaAppWebhook.ts`
+
+Handles inbound webhooks sent from Seeka to your app.
+
+### Queue example 
+`src/functions/queueExample.ts`
+
+Handles taking a message and placing it on an Azure storage queue for later processing. This concept can be used to offload long running operations based on data sent to your app from Seeka and can help to ensure Azure Function time execution limits are respected.
+
+### Polling example 
+`src/functions/pollingExample.ts`
+
+Handles scheduled invoking of a function. This concept can be used to "fan out" long running operations based on data sent to your app from Seeka and can help to ensure Azure Function time execution limits are respected by splitting long running operations into smaller, less time consuming parts.
+
+## Invoking functions
+### Development environment
+Scheduled / timer function: `curl -i -d '{"input": null}' -H "Content-Type: application/json" -X POST http://localhost:7072/admin/functions/pollingExample`
+
+### Azure cloud
+Scheduled / timer function: `curl -i -d '{"input": null}' -H "Content-Type: application/json" -H "x-functions-key: <key from azure portal>" -X POST https://seeka-app-complianz.azurewebsites.net/admin/functions/pollingExample`
+
+See [this doc](https://learn.microsoft.com/en-us/azure/azure-functions/functions-manually-run-non-http?tabs=azure-portal#get-the-master-key) on how to get the functions (master) key
+
+## Logging
+Centralised logging handled by [Winston](https://www.npmjs.com/package/winston). Winston is installed in this template and is also used in the Seeka SDK NPM packages.
+
+[Seq](https://datalust.co/seq) Winston transport is installed in this template (optional).
+
+To configure Seq options, see `_SEQ_` environment variables.
+
+To install Seq on your development machine
+1. Run `docker run --name seq -d --restart=always -e ACCEPT_EULA=Y -p 5341:80 datalust/seq:2024.2`
+2. Update your `LOGGING_SEQ_SERVERURL` environment variable to `http://localhost:5341` or `http://[YOUR MACHINE NAME].local:5341` if using WSL.
+
+If creating an API key for Seq, only permission that is required is `Ingest`.
+
+## State management
+Installations of your app and other state required for your app to function is stored in Redis. Another state provider can be swapped out for Redis, see `src/lib/state/seeka/installations.ts` for the file that manages the state of the installations.
+
+### Upstash (optional)
+If you dont want to use Upstash for Redis then the connection strings in `.env` can be swapped with your Redis instance. 
+
+> If using Upstash then create a database before following the below guide to deploying your AWS lambda function.
+
+> When choosing region - use a region that is closest to the Azure region that your function app is hosted in to reduce latency between the function and the Redis database. 
+
+## Deployment
+This project comes ready to deploy for free to Azure functions with database backed by Redis hosted by Upstash and queues, blobs and tables backed by Azure Storage.
+
+1. Create Azure function app via the portal with below settings
+    - Function app name: seeka-app-complianz
+    - Code or container image: Code
+    - Runtime stack: Node.js
+    - Version: 18 LTS
+    - Region: Closest region to where your upstash "master / write" database is located
+    - Operating system: linux
+    - Hosting: Consumption
+    - Enable public access: On
+2. Set environment variables of the Azure web app - reference local.settings.json "Values" 
+3. If your app receives calls directly from the browser (eg. your browser app plugin) then CORS needs to be enabled for all origins from within the settings of the Function app in Azure portal.
+3. `yarn deploy`
+
+### Continuous delivery
+This template includes a GitLab CD pipeline that can be used to trigger deployments of your app when changes are pushed to your Git repository.
+
+## References
+- https://learn.microsoft.com/en-us/azure/storage/common/storage-use-azurite
+- https://learn.microsoft.com/en-us/azure/storage/queues/storage-quickstart-queues-nodejs?tabs=connection-string%2Croles-azure-portal%2Cenvironment-variable-windows%2Csign-in-azure-cli

package/dist/ai-context/internal/examples/v1/complianz/_ai-summary.md

@@ -0,0 +1,34 @@
+# AI Summary for Seeka App: Complianz
+
+## Purpose and Functionality
+
+The "Complianz" app is designed to integrate consent management for GDPR and privacy compliance into Seeka applications. It facilitates the handling of user consent and privacy settings, ensuring that applications comply with regulatory requirements. The app is built using Azure Functions, providing serverless execution of its components.
+
+## Key Implementation Patterns
+
+1. **Azure Functions**: The app leverages Azure Functions to handle HTTP requests and manage asynchronous operations such as webhooks and queue processing.
+2. **Webhook Handling**: The app processes incoming webhooks from Seeka, validating signatures and managing installation states.
+3. **Queue Management**: Implements Azure Storage Queues for handling long-running operations asynchronously, ensuring compliance with Azure Function execution limits.
+4. **Polling Mechanism**: Utilizes scheduled functions to perform regular checks or operations, distributing workload over time.
+
+## External APIs/Services Integrated
+
+1. **Azure Functions**: Used for deploying and executing serverless functions.
+2. **Azure Storage**: Employed for queue management and storage emulation during development.
+3. **Ngrok**: Facilitates local development by exposing the app to the internet for testing.
+4. **Seq and Winston**: Integrated for centralized logging and monitoring of application events.
+5. **Redis**: Used for state management, storing installation data and other necessary state information.
+
+## Important Data Transformations
+
+- **Webhook Payload Processing**: The app parses and validates JSON payloads from incoming webhooks, ensuring data integrity and security through signature validation.
+- **State Management**: Transforms and stores installation data using Redis, allowing for efficient retrieval and updates.
+
+## Notable Code Patterns
+
+1. **Centralized Logging**: Utilizes Winston for logging, with optional Seq integration for enhanced log management and analysis.
+2. **State Management with Redis**: Provides a flexible and scalable approach to manage application state, with the option to replace Redis with other providers.
+3. **Error Handling**: Implements robust error handling in webhook processing to ensure graceful degradation and informative logging.
+4. **Environment Configuration**: Supports development and production environments with configurable settings for Azure and Redis connections.
+
+This summary provides an overview of the "Complianz" app's architecture and implementation, highlighting its integration with Azure services and its focus on privacy compliance. The app's design patterns and external integrations make it a robust solution for managing GDPR consent within Seeka applications.